Symbols

& (ampersands). See Ampersands (&)

<> (angle brackets)

generics, 540

XML, 33

* (asterisks). See Asterisks (*)

@ (at signs)

identifiers, 16–17

verbatim strings, 60

(backslashes)

escape sequence, 57–58

as literals, 60

^ (carets). See Carets (^)

: (colons). See Colons (:)

, (commas). See Commas (,)

{} (curly braces). See Curly braces ({})

$ (dollar signs) for string interpolation, 28, 61–62

" (double quotes)

escape sequence, 57, 59

strings, 59–60

= (equals signs). See Equals signs (=)

! (exclamation points). See Exclamation

points (!)

/ (forward slashes). See Forward slashes (/)

> (greater than signs). See Greater than signs (>)

# (hash symbols) for preprocessor directives, 186

- (hyphens). See Minus signs (-)

< (less than signs). See Less than signs (<)

- (minus signs). See Minus signs (-)

() (parentheses). See Parentheses ()

% (percent signs)

compound assignment, 132

overriding, 466, 468

precedence, 124

remainder operation, 123

. (periods)

fully qualified method names, 198

nested namespaces, 210, 483

null-conditional operator, 158

+ (plus signs). See Plus signs (+)

? (question marks)

command-line option, 783

conditional operators, 154–155

null-coalescing operator, 157–158

null-conditional operators, 158–160

; (semicolons)

ending statements, 20

for loops, 171–172

preprocessor directives, 189

' (single quotes)

characters, 57

escape sequence, 57

[] (square brackets)

arrays, 101–103, 108

attributes, 783–784

indexers, 750

null-conditional operators, 158–160

~ (tildes)

complement operator, 167

finalizers, 494

list searches, 736

overriding, 468

_ (underscores). See Underscores (_)

| (vertical bars)

bitwise operators, 164

compound assignment, 167

logical operators, 151–152

overriding, 466, 468

A

a escape sequence, 58

Abstract classes

defining, 357–360

vs. interfaces, 413–414

overview, 357

polymorphism, 361–363

abstract modifier

interface refactoring, 405

limitations, 357, 386

Access modifiers

base class overriding, 353–354

classes, 274–276

derivation, 341–344

finalizers, 495

getters and setters, 289–291

type declarations, 479–481

Accessing

arrays, 100, 106

base members, 354–355

instance fields, 264–265

properties, 425–426

referent type members, 970

static fields, 312–313

Accuracy of floating-point types, 128–129

Acronyms as identifiers, 15–16

Action delegate, 592–594

Activation frames, 216

Add() method

collection initializers, 298, 654–655

dictionaries, 739

interlocks, 927

lists, 733

Addition

binary operator, 123

compound assignment, 132

increment operator, 133

strings, 126–127

unary operator, 122–123

Address operator (&), 965

Addresses and pointers. See Pointers

AggregateException type, 247

asynchronous requests, 859–860

parallel loops, 900–901

PLINQ queries, 908, 911

publish-subscribe pattern, 640

tasks, 836–840, 847

wrapped exceptions, 517

Aggregation for inheritance, 345

Ahead of time (AOT) compilation, 993

Alerts escape sequence, 58

Aliases

command-line option, 789–793

namespaces, 213–214

Allow Unsafe Code option, 963

AllowMultiple parameter, 795

AllowNull attribute, 307

AllowUnsafeBlocks option, 962

Alternative statements for if statements, 142

Ampersands (&)

address operator, 965

bitwise operators, 164

compound assignment, 167

logical operators, 152

overriding, 466, 468

AND operations

bitwise operators, 164–165

enums, 444–445

logical operators, 152

Angle brackets (<>)

generics, 540

XML, 33

Anonymous functions, 600, 602

Anonymous methods, 600

internals, 610–611

lambda expressions as replacement for, 587–588

overview, 606–607

parameterless, 607–608

Anonymous types

collection initializers, 702–703

generating, 702

local variables, 697–701

overview, 91, 695–696

selecting into, 698–699

type safety and immutability, 700–701

Antecedent tasks, 830–831

Any() operator, 672

APIs (application programming interfaces)

documentation, 770

as frameworks, 40

wrapper calls, 959

AppDomain.CurrentDomain class

exceptions, 514

process exits, 506

AppDomains for unhandled exceptions, 841–843

Append() method, 69

AppendFormat() method, 69

Applicable calls, 238

ApplicationException type, 514

__arglist keyword, 17

args parameter for Main(), 18–19

ArgumentException type, 523

description, 247

nameof operator, 514

properties, 285

throwing exceptions, 511–512

ArgumentNullException type, 513–514

description, 247

properties, 285

ArgumentOutOfRangeException type, 513–514

Arguments

generics, 540

methods, 197–198, 201

named, 237–238

passed by value, 217

passing methods as, 590–592, 596

Arithmetic operations, characters in, 127–128

Arithmetic operators, 123–124

ArithmeticException type, 248

Arity

generic methods, 569, 581–582

tuples, 550–552

type parameters, 550

Array accessors, 106

Arrays

anonymous types, 702–703

assigning, 100

collection conversion to, 731

common errors, 117–119

declaring, 98–99, 101–102, 108–109

foreach loops, 657–658

forward accessing, 100

instance members, 114–115

instantiating and assigning, 102–106

length, 109–110

methods, 112–114

null-conditional operators, 159

overview, 99

parameters, 226–229, 552

ranges, 101, 111–112

redimensioning, 114

reverse accessing, 100

strings as, 115–117

unsafe covariance, 580

working with, 106–109

ArrayTypeMismatchException type, 248

as operator, 373–374

ASP.NET, 977

AsParallel() operator, 670, 906–907, 911

AspNetSynchronizationContext type, 889

Assemblies

APIs, 40

attributes, 784–785

boundaries, 479

building, 10–11

CIL, 34

CLI, 35, 986–989

constants, 324

extensions, 11

references, 472–479

AssemblyCopyrightAttribute, 787

AssemblyFileVersionAttribute, 787

AssemblyVersionAttribute, 786–787

Assert() method, 130

Assigning

arrays, 100, 102–106

nulls to references, 71

nulls to strings, 70

pointers, 964–965

tuples, 92–96

variables, 22–24

Assignment operators

associativity, 125

compound, 132, 167

delegates, 634, 641–642

null-coalescing, 157–158

overriding, 468

Associations

data with static members, 314

with instance fields, 263

Associativity of operators, 124–125

Asterisks (*)

comments, 32

compound assignment, 132

indirection operators, 968

multiplication, 123

overriding, 466–468

pointers, 963

precedence, 124

Async() method, 875

async operator, 861–867, 890–891

async return types, 869–870, 877–880

async void methods, 877–880

AsyncEnumberable class, 875–877

Asynchronous invocation, 818

Asynchronous lambdas, 881–887

Asynchronous methods return types, 877–881

Asynchronous pattern. See Task-based Asynchronous Pattern (TAP)

Asynchronous streams, 870–874

Asynchronous tasks

complexities from, 822–823

introduction, 824–828

task continuation, 829–836

task exceptions, 836–840

thread exceptions, 840–843

TPL, 823–824

AsyncState property, 828

At signs (@)

identifiers, 16–17

verbatim strings, 60

Atomic operations in multithreading, 819–820

AttachedToParent task continuation option, 832

Attributes

custom, 787, 992

description, 769

enum, 443

FlagsAttribute, 795–797

initializing, 789–793

vs. interfaces, 415

named parameters, 794–795

nullable, 306–309

predefined, 797

properties, 783–787

restricting, 793–794

retrieving, 787–789

System.ConditionalAttribute, 797–799

System.ObsoleteAttribute, 799–800

AttributeTargets flag, 794, 799

AttributeUsageAttribute class, 793–795, 797

Automatically implemented properties

read-only, 287, 305–306, 325–326

reference type, 305–306

structs, 423–424, 426

working with, 279–281

AutoResetEvent event, 937

Average() function, 693

Await() method, 876–877

await operator

iterating, 892–893

task-based asynchronous pattern, 861–867, 890–891

await using statement, 874–875

AwaitAsync() method, 875, 877

AwaitWithCancellationAsync() method, 875–876

B

 escape sequence, 58

Backslashes ()

escape sequence, 57–58

as literals, 60

Backspace escape sequence, 58

Base Class Library (BCL)

description, 977, 993

purpose, 35, 979

type names, 46–49, 56, 59

Base class overriding

constructor invocation, 355–356

members, 353–355

new modifier, 349–353

overview, 346

sealed modifier, 353–354

virtual modifier, 346–349

Base classes

derived object conversion to, 339

inheritance, 257–258

protected member access in, 344

Base types

casting between derived types, 339–340

classes, 258–259

description, 336

BCL (Base Class Library)

description, 977, 993

purpose, 35, 979

type names, 46–49, 56, 59

Binary digits (bits), 162–163

Binary expression trees, 618–619

Binary operators

associativity, 125

compound assignment, 132, 468

non-numeric types, 126–127

null-coalescing, 157

overriding, 466–467

overview, 123–124

relational and equality, 150–151

Binary values

conversions to, 165–167

floating-point, 47

literals, 53

shift operators, 163

BinaryExpression expression trees, 623

BinarySearch() method

arrays, 112–114

list searches, 736

BinaryTree<T> class

constraints, 553–557

index operators, 152

iterators, 755–756, 759–762

parameters, 572

Binding

dynamic, 801, 806–807

extension methods, 412

late, 518, 985, 992

metadata, 992

Bits (binary digits), 162–163

Bitwise operators

bits and bytes, 162–163

complement, 167, 736–737

compound assignment, 167

enums, 444–445

for positions, 181–182

shift, 163–164

working with, 164–167

Block statements. See Code blocks

BlockingCollection<T> class, 938–939

Boolean (bool) type

array initial values, 104

conversions, 75

flow control, 149

lambdas, 593

logical operators, 151–153

overview, 55–56

relational and equality operators, 150–151

Boolean expressions for if statements, 142

Boolean operators

logical, 151–155

overriding, 468–470

Bounds

arrays, 109–110

floating-point types, 131

Boxing

avoiding, 435–436

generics for, 543

idiosyncrasies, 432–434

in loops, 448

overview, 428–432

Brand casing for namespaces, 482

Break() method, 905

break statements

lambda expressions, 606

overview, 141

switch statements, 177–178

working with, 180–181

yield break, 764

Breaking parallel loops, 904–905

Brittle base class problem, 349–351

Bubble sorts, 588–602

Buffer overflows

C# vs. C++, 109–110

managed execution, 986

type safety, 35, 984

unsafe code, 962

byte type, 46

Bytes, 162–163

C

C language and C# syntax similarities, 2–3

C++ language vs. C#

arrays, 101–102

Boolean conversions, 75

buffer overflows, 109–110

delete operator, 262

deterministic destruction, 502, 983

equality checks, 150

global methods, 204

global variables and functions, 311

header files, 208

implicit overriding, 347

increment and decrement operators, 136

local variable scope, 149

Main(), 19

methods called during construction, 348–349

multiple inheritance, 345

operand evaluation, 126

operator-only statements, 123

pointer declarations, 964

preprocessor directives, 186

pure virtual functions, 361

short type, 47

string concatenation, 61

structs, 427

switch statements, 179

syntax similarities, 2–3

Variant and var, 90

void type, 71, 90

Calculated properties, 287–289

Call sites, 217

Call stacks for methods, 216–217

Callback functions, 587

CallerMemberName parameter attribute, 782

Calling

collection initializers, 297–298

constructors, 294–295

external functions, 956–958

object initializers, 296–297

CallSite<T> type, 805–806

camelCase

description, 16

parameter names, 205, 268, 300

property names, 282

tuples, 95

variable names, 24, 92

"can do" relationships, 377–378

Cancel() method

parallel iterations, 903

PLINQ queries, 911

tasks, 845–846

Canceling

iterations, 763–764

parallel loops, 901–903

PLINQ queries, 908–911

tasks, 843–849

CancellationToken class

asynchronous methods, 885

asynchronous streams, 872–873

overview, 843–847

PLINQ queries, 911

CancellationToken property, 904

CancellationTokenSource class, 845–846, 903, 911

Capacity of lists, 731–733

Capture() method, 517

Captured outer variables, 611–612

Carets (^)

arrays, 107–108

bitwise operators, 164

compound assignment, 167

index from end operator, 99, 107, 108, 110, 112, 118

logical operators, 152

overriding, 466, 468

Carriage returns

escape sequence, 58

newlines, 66

Cartesian products

inner joins, 684

query expressions, 723

Case labels

goto statements, 185

switch statements, 177, 179

Case sensitivity

C++ similarity, 3

importance, 2

literal suffixes, 52

suffixes, 51–52

Casing

identifier formats, 15–16

local variables, 24

cast operator and casting

base and derived types, 339–340

defining, 341

enums, 440–441

generic methods, 572–573

implicit conversions, 76

in inheritance chains, 340

overriding, 470–471

overview, 72–77

Catch blocks

exceptions, 514–516, 518–520

general, 248–249

rethrowing exceptions, 251

working with, 242–245

Catching exceptions, 241–242, 514–516, 518–519

cells member in arrays, 115

Central processing units (CPUs)

description, 815

multithreading, 814, 818

PLINQ queries, 670

Centralizing constructor initializers, 301–302

Chains

circular, 930

constructors, 300–301

delegates, 633–634, 637–638, 640

expressions, 158–160

inheritance, 338–340

iterators, 762

null-coalescing operator, 158

queries, 722

tasks, 830–831, 853

Characters (char) types

arithmetic operations, 127–128

array initial values, 104

description, 23, 56

Checked conversions, 73–75, 528–530

checked keyword, 73–75, 529–530

CheckForOverflowUnderflow property, 529

Child types, 258, 336

Church, Alonzo, 608

CIL. See Common Intermediate Language (CIL)

Circular wait conditions in deadlocks, 930

Class definitions

description, 17

guidelines, 17

class keyword, 259

Classes

abstract, 357–363

access modifiers, 274–276

associated data, 314

concrete, 357

constraints, 560–561

constructors. See Constructors

declaring, 259–260

deconstructors, 309–311

defined, 260

delegates, 597–600

encapsulation, 261–262, 323–326

extension methods, 321–322

files for storing and loading, 270–273

generics, 540–544, 779–780

hierarchy, 257–258

inextensible, 320

inheritance. See Inheritance

instance fields, 262–265

instance methods, 265–266

instantiating, 260–261

interfaces. See Interfaces

libraries, 472–475

members, 262

methods, 197–198

multiple interfaces, 545–546

multiple iterators in, 766–767

nested, 326–328

nullable attributes, 306–309

object-oriented programming, 256–259

overview, 255–256

partial, 329–332

properties. See Properties

refactoring, 336–337

sealed, 345

static, 319–321

static members. See Static members

vs. structs, 763

this keyword, 266–270

Clear() method, 112, 114

CLI. See Common Language Infrastructure (CLI)

Clock speeds, 813

Clone() method, 114–115

Close() method, 497

Closed over outer variables, 611–612

Closures, 614

CLR (Common Language Runtime)

description, 982, 994

enums, 440–441

namespaces, 481–483

CLS (Common Language Specification)

description, 994

libraries, 35

metadata, 991

CLSCompliant attribute, 991

CLU language, 754

Clusters, 754

Code access security, 35

Code blocks

error trapping, 242–244

if statements, 144–147

loops, 169–170

scope, 147–149

Code editors for preprocessor directives, 191–193

Code readability. See Readability

CodeAnalysis class, 306–309

Cold tasks, 825

Collect() method, 490, 506

Collections

anonymous types, 702–703

class categories, 731–733

dictionaries, 738–744

foreach loops, 174–175, 661–662

IEnumerable<T>, 657–663

indexers, 750–752

initializers, 297–298, 654–657, 702–703

interfaces, 653–654, 728–731

iterators. See Iterators

join operations. See Join operations

linked lists, 749

null values, 753

overview, 727–728

queues, 748

searching, 736–738

shared states, 660

sorted, 745–747

sorting, 734–735

stacks, 747

standard query operators. See Standard query operators

thread synchronization, 938–939

total ordering, 735–736

Collisions, name, 198

Colons (:)

conditional operators, 154–155

constraints, 561

constructors, 301

derived classes, 336

hexadecimal format, 54

labels, 185

COM threading model, 945

Combine() method

delegates, 558–559, 634, 650–651

hash codes, 455

parameters, 217–218, 220, 226–229

COMException type, 514

Command-line arguments, 19, 214–216

CommandLineInfo class, 773–779

CommandLineRequiredAttribute, 797

CommandLineSwitchAliasAttribute, 797

CommandLineUtils package, 773n

Commas (,)

arrays, 99, 102, 104, 106

attributes, 787

constraints, 561

enums, 447

for loops, 173

interfaces, 384

methods, 201

parameters, 205

variable declarations, 23, 499

Comments

guidelines, 33

overview, 30–33

XML, 485–489

Common Intermediate Language (CIL)

anonymous types, 697–698

assemblies, 34

boxing code, 428–432

compilation to, 974–975

description, 994

events, 649–650

general catch blocks, 519

generics representation, 581–582

ILDASM, 36

indexers, 751

metadata, 770, 991–992

outer variable implementation, 613–614

output, 37–39

properties, 291–293

purpose, 989–990

Common Language Infrastructure (CLI)

assemblies, 986–989

Base Class Library, 979

CIL, 989–990

CLS, 991

compilation to, 979–981

CTS, 990

description, 974–975, 994

encapsulation, 985

garbage collection, 982–984

implementations, 975–976

manifests, 986–989

metadata, 991–992

Microsoft .NET Framework, 975–977

modules, 986–989

multicast delegates, 636–637

namespaces, 482

.NET Core, 977–978

.NET Native feature, 993

.NET Standard version, 978–979

overview, 34–35, 973

P/Invoke, 948–960

performance, 985–986

platform portability, 985

runtime, 982–984

type safety, 984

Xamarin compiler, 978

Common Language Runtime (CLR)

description, 982, 994

enums, 440–441

namespaces, 481–483

Common Language Specification (CLS)

description, 994

libraries, 35

metadata, 991

Common Type System (CTS), 34, 990, 994

Compacting objects in garbage collection, 490

Compare() method, 56, 63

CompareExchange() method, 926–927

CompareTo() method

collection sorts, 734–735

interfaces, 556–557

tree sorts, 553–554

Comparing

binary tree nodes, 556–557

collections items, 734–735

compare/exchange pattern, 926–927

floating-point types, 129–130

strings, 56, 63

Comparison operators

overriding, 464–465

pointers, 969

Compatibility between enum types, 440–441

Compilation

ahead of time, 993

assemblies, 10–11

disassembling, 36

to machine code, 979–981

sample output, 37–39

source code, 3–8, 34–35

static vs. dynamic, 807–808

CompilerGeneratedAttribute, 293

Complement operator (~), 167

Complexity of asynchronous requests, 859–861

ComponentModel class, 953

Components in compilation, 980

Composite formatting

description, 29

patterns, 65

strings, 127

Compound assignment

bitwise, 167

mathematical operators, 132

overriding, 468

Compress() method, 379

Concat() method for strings, 62–63

Concat() operator for queries, 693

Concatenating strings, 61–63, 126–127

Concrete classes, 357

Concurrent collection classes, 938–939

Concurrent operations, 817–818

ConcurrentBag<T> class, 939

ConcurrentDictionary<TKey, TValue> class, 939

ConcurrentQueue<T> class, 939

ConcurrentStack<T> class, 939

Conditional clauses in catch blocks, 516

Conditional operators

null. See Null-conditional operator

overriding, 468

working with, 154–155

Conditional types, 55–56

ConditionalAttribute, 797–799

ConditionalExpression expression trees, 623

Conditions

for loops, 172

if statements, 142

Consequence statements in if statements, 142

Console

comments, 30–33

input, 26–27, 197

newlines, 59, 66

output, 19, 28–33, 197

round-trip formatting, 54–55

string methods, 62

const keyword

constants, 137–138

encapsulation, 323–324

ConstantExpression expression trees, 623

Constants

expressions and locals, 137–138

pattern matching, 366–368

switch statements, 177

Constraints

classes, 560–561

constructor, 562–565

delegates, 558–559

generic methods, 571–572

inheritance, 565–567

interfaces, 554–557

limitations, 567–568

multiple, 561–562

notnull, 560

operators, 567–568

overview, 553–555

structs, 560–561

type parameters, 557–558

unmanaged, 559–560

Constructed struct types, 560

Constructors

attributes, 789–793

base classes, 355–356

chaining, 300–301

collection initializers, 297–298

constraints, 562–565

declaring, 293–295

default, 295–296

finalizers, 298

generics, 547

initializers, 300–302

methods called during, 348–349

new operator, 294–295

non-nullable reference type properties, 303–306

object initializers, 296–297

overloading, 298–300

overview, 293

propagating exceptions from, 507

static, 316–318

structs, 424

Contains() method

list searches, 736

stack searches, 747

ContainsGenericParameters property, 779–780

ContainsKey() method, 741

ContainsValue() method, 741

Context switches, 137, 817–820, 850

Contextual keywords, 15, 766

Continuation of tasks, 829–836

continue statements

lambda expressions, 606

overview, 140

switch statements, 177

working with, 182–184

ContinueWith() method

asynchronous requests, 859

synchronization context, 888–889

tasks, 829–831, 834–835, 839–840

Contravariance

delegates, 609

generics, 573–580

type parameters, 577–579

Control flow. See Flow control

Conversions

as operator, 373–374

to binary representation, 165–167

Boolean type, 75

boxing, 428–432

casts. See cast operator and casting

checked and unchecked, 73–75, 528–530

collections to arrays, 731

covariant, 574

dynamic objects, 803

enums, 439–443

explicit, 72–73

false return values, 77–79

implementing classes and interfaces, 390

implicit, 75–76

overriding operators, 470–472

overview, 72

type safety, 35

without casts, 76–77

Cooperative cancellation, 843–847

Copying

arrays, 115

directories, 316, 321–322

null values, 85

reference types, 83–84, 421

variables, 418–419

CopyTo() method

collections, 730–731

directories, 316, 321–322

Core .NET frameworks, 39

CoreCLR compiler, 975, 977

Cores, 670, 815, 817

Count() method

description, 693

elements, 671–674

index-based collection, 412

Count property for collections, 730–731

CountdownEvent event, 937–938

CountOccurrencesAsync() method, 860–861, 864–866

Covariance

in arrays, 580

delegates, 609

generics, 573–580

out modifier, 575–577

CPUs (central processing units)

description, 815

multithreading, 814, 818

PLINQ queries, 670

Create() method, 551

Cryptographer class, 874

.cs file extension, 9

CTS (Common Type System), 34, 990, 994

Curly braces ({})

arrays, 102–103

classes, 259

code blocks, 144–147

code formatting, 22

collection initializers, 297, 655–656

lambda expressions, 603

methods, 18

namespaces, 482

object initializers, 296

pattern matching, 370

properties, 278

string interpolation, 29, 61–62, 66

switch statements, 20

type definitions, 17

use of, 19

Current property for iterators, 764

CurrentDomain class

exceptions, 514

process exits, 506

CurrentId property for asynchronous tasks, 828

Custom attributes, 787, 992

Custom conversions, 340–341

Custom exceptions, 523–526

Custom objects in dynamic programming, 808–811

Custom value types for structs, 422–427

D

Data namespace, 199

Data persistence, files for, 270–273

Data types. See Types

DataBinder class, 771

Deadlocks

avoiding, 929–930

causes, 821–823

Debug() method, 799

DEBUG preprocessor identifier, 799

Debugging

preprocessor directives for, 188

source code, 8–9

Decimal type, 49

Declaration spaces in code blocks, 147–149

Declaring

arrays, 98–99, 101–102, 108–109

await using statement, 874–875

BinaryTree<T> class, 553–554

class type constraints, 557–558

classes, 259–260

constants, 323

constructors, 293–295

deconstructors, 311

delegate types, 592–595

enums, 437–438

events, 643–644, 648–649

external methods, 948–949

generic interfaces, 544–545

generic methods, 568–569

instance fields, 263–264

interface constraints, 556–557

local variables, 22–23

Main() method, 18–19

methods, 203–204

namespaces, 482–484

out variables, 222

parameters, 205

pointers, 963–964

properties, 277–279

read-only automatically implemented properties, 325–326

read-only fields, 324–325

return types, 206–208

static constructors, 316–318

static fields, 312

structs, 422–423

tuples, 92–96

types from unmanaged structs, 952–953

variables, 23–24

Deconstructors, 309–311

Decrement() method, 137, 927–928

Decrement operators

description, 133

loop example, 133–136

thread-safe, 137

Default constructors, 295–296

Default interface members

vs. extension methods, 411–413

versioning, 398–400

default operator for generics, 547–549

default sections in switch statements, 179, 184

Default types, 50–52

Default values

generics, 547–549

structs, 424

DefaultIfEmpty() method, 688–689

Deferred execution

LINQ, 672–676

query expressions, 711–715

#define directive, 187, 189

Defining

abstract classes, 357–360

attributes, 786

calculated properties, 288–289

cast operators, 341, 470–471

custom conversions, 340–341

custom exceptions, 523–526

enums, 438–439, 445

finalizers, 494–495

generic classes, 542

generic constructors, 547

generic methods, 568–570

indexers, 750–752

iterators, 754

namespaces, 481–484

nested classes, 326–328

partial classes, 329–332

preprocessor symbols, 189

publishers, 627–628

stacks, 537

static methods, 315–316

subscriber methods, 626–627

Delay() method, 944

Delegate class, 597–598

delegate keyword, 592

Delegate type, 558–559

Delegates

constraints, 558–559

deferred execution, 715

event notifications, 928–929

events, 647–648

vs. expression trees, 620–621

function pointers to, 960

instantiating, 595–597

internals, 597–600, 636–637

introduction, 588–590

invoking, 629–632, 634–636

method returns and pass-by-reference, 640

nesting, 594–595

null-conditional operators, 161

overview, 587–588

predicates, 666–667

process exits, 506

publish-subscribe pattern operators, 633–634

statement lambdas for, 601–604

structural equality, 608–609

tasks, 824

types, 590–594

unsafe code, 971–972

delete operator, 262

Deleting files, 496

Delimited comments, 32

Delimiters, 19–20

DenyChildAttach task continuation option, 832

Dependencies in libraries, 10

Dequeue() method, 748

Dereferencing

description, 83

null-conditional operator for, 513

null references, 85–86

null values, 87

pointers, 968–970

Derivation

casting between base and derived types, 339–340

custom conversions, 340–341

extension methods, 344

interfaces, 397–398

overview, 336–338

private access modifier, 341–342

protected access modifier, 342–344

sealed classes, 345

single inheritance, 345

from System.Object, 363–365

Derived members, 335

Derived objects converted to base class, 339

Derived types

casting between base types, 339–340

classes, 258–259

description, 336

DescriptionAttribute, 786

Deserialize() method, 572–573

Deterministic destruction, 502, 983

Deterministic finalization, 496–500

Deterministic resource cleanup, 262

Diagnostics class

debugging with, 799

notifications, 885

nullable attributes, 306–309

processes, 815

Diagramming interfaces, 395–396

Dictionaries

collection initializers, 656

interfaces, 728–730

key equality, 743–744

sorted, 745–747

thread synchronization, 939

working with, 738–743

Dictionary<TKey, TValue> class

collections, 658

working with, 738–743

Digit separators, 52–53

Dimensions for arrays, 102–106, 114

Directives

dynamic, 803

preprocessor. See Preprocessor directives

strings, 64–65

Directories, copying, 316, 321–322

DirectoryInfo class

extension methods, 321

inner joins, 682

DirectoryInfoExtension class, 315–316, 321–322

DisallowNull attribute, 307

Disambiguating multiple Main() methods, 214–216

Disassembling programs, 36

Discards

out parameters, 222

tuples, 96

DispatcherTimer class, 944

Disposability of tasks, 849

Dispose() method

collections, 661

finalization, 500–502

resource cleanup, 495, 497–499

DisposeAsync() method, 874–875

Distinct members in query expressions, 723–724

Distinct() operator

description, 693

query expressions, 723–724

Division

binary operator, 123

compound assignment, 132

shift operators, 164

by zeros, 131

DllImport attribute, 949, 953

DLLs (dynamic link libraries), 10–11

do/while loops

overview, 140

working with, 168–170

Documentation

reflection, 770

XML files, 487–489

Dollar signs ($) for string interpolation, 28, 61–62

DotGNU Portable.NET compiler, 976

Dotnet CLI

code building and executing, 12

NuGet references, 475–476

project and library references, 474

working with, 4–6

Double quotes (")

escape sequence, 57, 59

strings, 59–60

double type

overview, 47–49

special characteristics, 128–129

DownloadData() method, 856

DownloadDataTaskAsync() method, 858–860, 865

DownloadString() method, 856

Drawing class, 199

Duck typing, 662

Duplicating interfaces, 545–546

dynamic data type principles and behaviors, 803–805

Dynamic invocation

delegates, 558–559

members, 773–779

nameof operator, 781–782

Dynamic link libraries (DLLs), 10–11

Dynamic programming

binding, 806–807

custom objects, 808–809

description, 769

overview, 800–801

principles and behaviors, 803–805

reflection, 801–802

vs. static compilation, 807–808

DynamicInvoke() method, 558–559

DynamicObject class, 808–811

E

Editors

dotnet CLI, 4–6

preprocessor directives, 191–193

source code, 3–4

Visual Studio 2019. See Visual Studio 2019

Elements, counting, 671–672

#elif directive, 186, 188

else clauses, 142

#else directive, 186, 188

Empty collections, 753

Empty property for events, 645

Empty strings, 70

Encapsulation

classes, 261–262

CLI, 985

const modifier, 323–324

information hiding, 274–276

object-oriented programming, 257

with protected interface members, 406–411

publications, 642–643

readonly modifier, 324–326

subscriptions, 641–642

well-formed types, 479–481

EncryptAsync() method, 874

#endif directive, 188

#endregion directive, 191–193

EndsWith() method, 63

Enqueue() method, 748

Enter() method with monitors, 432, 918–920, 922–924

Enum class, 439, 442

enum values

conversions, 441–443

flags, 443–447

FlagsAttribute, 795–797

metadata, 772–773

overview, 437–440

parsing, 78

type compatibility, 440–441

Enumerable class

delegates, 621

element counting, 671–672

filters, 667

inner joins, 682, 684–688

methods, 691–693

parallel queries, 907

query expressions, 714

sorts, 676–678

standard query operators, 663

Enumerator patterns for iterators, 754–755

Environment class

command-line arguments, 19, 216

newlines, 66

thread synchronization, 933

Equality

C# vs. C++, 150

collections, 744–745

delegates, 608–609

dictionary keys, 743–744

floating-point types, 129–132

with null, 156–157

objects, 456–459

operators, 150–151

EqualityComparer<T> class, 463, 743

Equals() method

collections, 744–745

description, 364

with GetHashCode(), 453–454, 744

implementing, 460–462

null values, 87

overriding, 455–464

reflection, 427

Equals signs (=)

compound assignment, 132, 167, 468

delegates, 632–634, 641–642, 650

equality operator, 55

null checks, 86

null-coalescing operator, 157–158

overriding, 464–465

pointers, 969

precedence, 124

properties, 278

relational and equality operators, 150–151

shift operators, 163–164

variable assignment, 24–25

Equi-joins, 688

#error directive, 187, 189–190

Error handling. See also Exceptions

catch blocks, 248–249

exception class inheritance, 246–248

with exceptions, 239–240

P/Invoke, 953–955

publish-subscribe pattern, 637–640

throw statements, 249–251

trapping, 241–246

Errors

array coding, 117–119

preprocessor directives for, 186–191

Escape sequences, 57–58

Essential source code, 12–13

EssentialCSharp.sln file, 12

Etch A Sketch game, 534–537

Evaluation of operators, 125

event keyword, 643–644

EventArgs class, 645–647

EventHandler<T> class, 644, 647–648, 650–651, 887

Events

coding conventions, 644–647

declaring, 643–644, 648–649

generics and delegates, 647–648

implementation, 650–651

internals, 648–650

listeners, 835–836

overview, 625

publication encapsulation, 642–643

publish-subscribe pattern. See Publish-subscribe pattern

purpose, 641

subscription encapsulation, 641–642

thread synchronization, 928–929

Exception conditions, 516

Exceptional continuation, 829

ExceptionDispatchInfo class

asynchronous requests, 860

purpose, 517–518

Exceptions

catch blocks, 248–249, 514–516, 518–519

class inheritance, 246–248

custom, 523–526

error trapping, 241–246

expected situations, 252–253

guidelines, 514, 519–523

overview, 239–240, 511

parallel loops, 900–901

PLINQ queries, 908, 911

propagating from constructors, 507

publish-subscribe pattern, 637–640

rethrowing, 517–518, 522–523, 527–530

serializable, 526

tasks, 836–840

threads, 840–843

throw statements, 249–251

types, 511–514

ExceptionServices class, 517

Exchange() method, 927

Exclamation points (!)

equality operators, 55

generics, 582

inequality operators, 150–151

logical operators, 153

null-forgiving operators, 160–161

overriding, 464–465, 468

pointers, 969

Excluding code, preprocessor directives for, 188

Exclusive OR (XOR) operators

bitwise, 164–165

logical, 152–153

Executables, stand-alone, 11–12

ExecuteSynchronously task continuation option, 833

Execution time, 35

ExecutionEngineException type, 514

Exit() method with monitors, 432, 918–920, 923–924

Expanded form for parameters, 227

Explicit casts

base and derived types, 339

enums, 440–441

guidelines, 471–472

overview, 72–73

Explicit deterministic resource cleanup, 262

Explicit member implementation, 386–390

Exponential notation, 52

Expression bodied members

declaring, 208

properties, 279

Expression trees

deferred execution, 715

vs. delegates, 620–621

description, 616

examining, 621–623

object graphs, 618–619

SQL queries, 617–618

Expressions

constant, 137–138

lambda. See Lambda expressions

query. See Query expressions

Extended Application Markup Language (XAML), 977

Extensible Markup Language. See XML (Extensible Markup Language)

Extension methods

classes, 321–322

vs. default interface members, 411–413

derivation, 344

interfaces, 394–395

Extensions, file, 9

External methods and functions

calling, 956–958

declaring, 948–949

F

f escape sequence, 58

f-reachable (finalization) queues, 298, 500–501

Factory interfaces for constructor constraints, 564

FailFast() method, 514

Failure type, 514

false operator, overriding, 468–470

Fat arrow notation (=>) for lambda expressions, 608

FCL (Framework Class Library), 979, 993–994

Fibonacci numbers, 168–169

Fields

guidelines, 281–283

instance. See Instance fields

static members, 311–314

strings, 66

thread synchronization, 926

FIFO (first in, first out) collections, 748

FileAttributes class, 443

FileInfo class

inner joins, 682

projections, 668–669, 717–718

query expressions, 710

Files

deleting, 496

extensions, 9

Java language vs. C#, 10

project, 10

storing and loading with, 270–273

FileStream class

finalizers, 495

IAsyncDisposable, 874

storing and loading files, 270–273

ToString(), 452

Filters

Browse, 477

collections, 593–594, 666–667, 672–676

exceptions, 521–523

query expressions, 706, 715–716

Finalization, deterministic, 496–500

finalization (f-reachable) queues, 298, 500–501

finalize() method, 364

Finalizers

constructors, 298

generics, 547

resource cleanup, 493–496, 500–501

structs, 426–427

finally blocks in error trapping, 244–246

FindAll() method, 737–738

First in, first out (FIFO) collections, 748

fixed statement for pointers, 966–967

Flags, enums as, 443–447

FlagsAttribute

enums, 446–447

overview, 795–797

Flatten() method, 860

Flattening sequences in query expressions, 722–723

float type

overview, 47–48

special characteristics, 128–129

Floating-point types

equality issues, 129–132

overview, 47–49

special characteristics, 128–129

Flow control

Boolean expressions, 149–155

code blocks, 144–147

description, 121

for loops, 170–174

foreach loops, 174–175

if statements, 142–144

introduction, 138–141

jump statements, 180–185

preprocessor directives, 186–193

scope, 147–149

switch statements, 176–179

task continuation, 829

threads, 816

while and do/while loops, 168–170

for loops

overview, 140, 170–174

parallel iterations, 895–898

For() method, 897–898

Forcing resource cleanup, 503–507

foreach loops

arrays, 657–658

async streams, 873–874

collections, 661–662

enumerator patterns, 754

IEnumerable<T>, 658–659, 662–663

overview, 140, 174–175

parallel iterations, 898–899

Form feeds escape sequence, 58

Formal parameter lists, 205

Format items, 29

Format() method, 62–63, 65

Format strings, 29–30

FormatException type, 244, 247

FormatMessage() method, 953

Formatting

hexadecimal format, 54

round-trip, 54–55

with string interpolation, 28

strings, 65–66

Forward accessing arrays, 100

Forward slashes (/)

command-line option, 783

compound assignment, 132

overriding, 466, 468

precedence, 124

XML comments, 32, 486–487

XML elements, 33

Fragile base class problem, 349–351

Framework Class Library (FCL), 979, 993–994

Framework Design Guidelines, 15

Frameworks

APIs, 40

.NET. See .NET frameworks

from keyword in query expressions, 707–709, 714, 722–723

FromCurrentSynchronizationContext() method, 887

Full outer joins, 679

Fully qualified method names, 198

Func delegate, 592–594

Functions

external, 956–958

pointers to delegates, 960

G

Garbage collection

CLI, 982–984

managed execution, 35

Microsoft .NET framework, 489–491

objects, 261

overview, 489

resource cleanup. See Resource cleanup

weak references, 491–493

GC class

finalization, 500

finalizers, 496

garbage collection timing, 490

resource cleanup, 506–508

General catch blocks, 248–249, 518–520

Generics

benefits, 543–544

CIL representation, 581–582

classes, 540–544

constraints. See Constraints

constructors, 547

covariance and contravariance, 573–580

default values, 547–549

defining, 542

delegates, 609

events, 647–648

examples without, 534–539

finalizers, 547

instantiating, 582–584

interfaces and structs, 544–546

internals, 580–584

introduction, 539–540

Java, 584–585

lazy loading, 509–510

linked lists, 749

methods, 568–573

nested, 552–553

overview, 533

reflection, 779–781

tuples, 550–552

type parameters, 308–309, 542–545, 549–552, 780–781

working with, 540–542

get keyword for properties, 278–279

GetAsyncEnumerator() method, 872–873

GetAwaiter() method, 870, 881

GetCommandLineArgs() method, 216

GetCustomAttributes() method, 788–790

GetEnumerator() method

duck typing, 662

iterators, 755, 757–761

purpose, 660

queryable extensions, 694–695

standard query operators, 663

GetFiles() method

directories, 321

inner joins, 682

GetGenericArguments() method, 780

GetHashCode() method

collections, 744–745

description, 364

overriding, 453–455, 463–464

value types, 427

GetLastError() method, 953

GetLength() method, 114

GetMethods() method, 771

GetProperties() method, 771–772

GetResult() method, 881

getters

access modifiers, 289–291

properties, 67, 278–279

GetType() method

description, 364

null values, 87

objects, 462

reflection, 771–773

GetValue() method, 777

GhostDoc tool, 489

Global methods, 204

Global variables and functions, C# vs. C++ and Visual Basic, 311

"goes to" operator, 208

goto statements

lambda expressions, 606

overview, 141

switch statements, 184–185

Graphs for expression trees, 618–619

Greater than signs (>)

generics, 540

overriding, 464, 466

pointers, 969

referent member access, 970

relational operators, 150

shift operators, 163–164

XML, 33

group clauses in query expressions, 707, 720–722

group by clause, 719

GroupBy() method, 685–686

Grouping query expressions, 718–721

GroupJoin() method

inner joins, 686–688

outer joins, 688–691

H

Handle() method

asynchronous requests, 860

task exceptions, 839

Handlers for process exits, 506

Hardcoding values, 50

HasFlags() method, 444

Hash codes and tables

collection equality, 744–745

dictionaries, 741

GetHashCode(), 453–455

Hash symbols (#) for preprocessor directives, 186

Hat operator (^) for arrays, 107–108

Header files, 208

Heap

boxing, 428

new operator, 262

reference types, 83, 420–421

HelloWorld.dll file, 10

HelloWorld program

assemblies, 10–11

CIL output, 37–39

compiling, 10–11

debugging, 8–9

description, 2–3

dotnet CLI for, 4–6

preparing, 3–4

project files, 9–10

stand-alone, 11–12

Visual Studio 2019 for, 6–8

Hexadecimal numbers

formatting numbers as, 54

notation, 52–53

Unicode characters, 58

HideScheduler task continuation option, 833

Hierarchy of classes, 257–258

High-latency operations

async/await syntax, 862–867

asynchronous example, 856–858

synchronous example, 854–856

WPF example, 889–891

Hill climbing, 899

Hold and wait conditions in deadlocks, 930

Hooking up publishers and subscribers, 628–629

Horizontal tabs escape sequence, 58

Hot tasks, 825

Hungarian notation, 16

Hyper-Threading, 815

Hyphens (-). See Minus signs (-)

I

I/O-bound operations

latency, 814

performance considerations, 818–820

IAsyncDisposable interface, 874–875

IAsyncEnumerable<T> interface

async returns, 880–881

asynchronous streams, 872–874

LINQ with, 875–877

IAsyncEnumerator<string> interface, 877, 881

ICollection<T> interface

collection initializers, 654–655

element counting, 671–672

members, 730–731

IComparable<string> interface, 734

IComparable<T> interface, 554–557, 572

IComparer<T> interface, 734–735

Id property for asynchronous tasks, 828

IDE (integrated development environment)

debugging support, 8

Visual Studio 2019, 6

Identifiers

guidelines, 16

keywords as, 17

overview, 15–16

Identity of objects, 456–459

IDictionary<TKey, TValue> interface, 728–730

IDisposable interface

resource cleanup, 497–501, 661–662

tasks, 849

IDynamicMetaObjectProvider interface, 808

IEnumerable<T> interface

collections, 657–663, 730–731

delegates, 620–621

element counting, 671–672

filters, 667

foreach loops, 658–663, 754

iterators, 755, 760

PLINQ queries, 911

projections, 669

query expressions, 708–709, 714

standard query operators, 663

task-based asynchronous pattern, 877

yield statement, 767

IEnumerator<T> interface

foreach loops, 658–662

iterators, 755–756, 764

yield statement, 767

IEqualityComparer<T> interface, 743–744

IEquatable<T> interface, 463

#if directive, 186, 188

if statements

Boolean expressions, 149

code blocks, 144–147

continue statement replacement, 183–184

nested, 142–144

overview, 139

switch statements for, 178

working with, 142

IFileCompression interface, 379

IGrouping type, 719, 721

ILDASM (IL Disassembler), 36–37

IList<T> interface, 728–730

IList<TKey> interface, 746

IList<TValue> interface, 746

Immutability

anonymous types, 700–701

delegates, 598

strings, 26, 67–69, 968–970

value types, 424

Immutable library, 939

Implementing class conversions with interfaces, 390

Implicit conversions

base and derived types, 339

guidelines, 471–472

types, 72, 75–76

Implicit deterministic resource cleanup, 262

Implicit member implementation, 386–390

implicit operator for types, 75–76

Implicitly typed local variables, 89–90

import directive, 210

in parameters, 223

Including code, preprocessor directives for, 188

Increment() method, 137, 927–928

Increment operators

description, 133

prefix and postfix, 134–136

thread-safe, 137

Indenting code

if statements, 144, 146

readability, 21–22

Index operator

lists, 731–733

variable parameters, 752

Index from end operator, 99, 107, 108, 110, 112, 118

Index type, 112

IndexerNameAttribute, 751

Indexers, 750–752

Indexes

arrays, 99, 107–108

dictionaries, 740–741

list searches, 736

sorted collections, 746

IndexOf() method, 736

IndexOutOfRangeException type, 247

Indirection operators for pointers, 968–969

Inequality

floating-point types, 129–132

with null, 156–157

operators, 150–151

Inextensible classes, 320

Inferences for generic methods, 569–571

Infinite recursion errors, 231

Infinity value, 131

Infix notation for binary operators, 123

Information hiding in encapsulation, 274–276

Inheritance

abstract classes, 357–363

base class overriding. See Base class overriding

casting in, 340

constraints, 565–567

definitions, 335–336

derivation. See Derivation

exception classes, 246–248

interfaces, 390–393

is operator, 365–371

overview, 257–259, 335

System.Object class in, 363–365

value types, 427

Initial section in for loops, 172–173

Initialization, lazy, 508–510

Initializers

collections, 297–298, 654–657

constructors, 300–302

object, 296–297

Initializing

anonymous type arrays, 702–703

arrays, 104–106, 108

attributes, 789–793

dictionaries, 656

fields, 548

loop counters values, 170

static members, 312–313, 317–318

structs, 424–426

Inner classes, 328

Inner joins

description, 679

one-to-many relationships, 686–688

performing, 682–686

InnerException property, 522, 525, 527

InnerExceptions property

aggregate exceptions, 838, 908

asynchronous requests, 860

error handling, 640

parallel loops, 901

tasks, 838

INotifyCompletion interface, 881

INotifyPropertyChanged interface, 782

Input, console, 26–27

Insert() method, 69

Inserting dictionary items, 740–741

Instance fields

accessing, 264–265

declaring, 263–264

description, 262–263

initializing, 312–313

Instance members

arrays, 114–115

strings, 62

working with, 265–266

Instantiation

arrays, 102–106

classes, 260–261

defined, 19

delegates, 595–597

generics, 582–584

Integers and int type

characteristics, 46–47

characters, 127

conversions, 72

default, 50

description, 23

enums, 439

overflow, 528–530

vs. strings, 240–241

Integrated development environment (IDE)

debugging support, 8

Visual Studio 2019, 6

IntelliSense feature, 708

Interfaces

vs. abstract classes, 413–414

vs. attributes, 415

collections, 728–731

constraints, 554–557

converting between implementing classes, 390

default members, 411–413

deriving, 397–398

diagramming, 395–396

duplicating, 545–546

extension methods, 394–395, 411–413

generics, 544–546

implementation, 377–378, 384–390

inheritance, 390–393

overview, 377

polymorphism, 380–384

purpose, 378–380

refactoring features, 401–405

value types, 427

versioning. See Versioning

Interlocked class

increment and decrement operators, 137

working with, 926–928

internal access modifier

description, 481

interface refactoring, 402

on type declarations, 479–480

Interoperability. See Platform interoperability

InteropServices class

SafeHandle, 955–956

unmanaged exceptions, 519

Interpolation of strings, 28–30, 61–62

Intersect() operator, 693

into clause in query expressions, 721–722

IntPtr class, 951, 963

InvalidAddressException type, 523

InvalidCastException type

description, 247

generics, 543

using, 472

InvalidOperationException type

catch blocks, 516–517

collections, 663

description, 247

null values, 87

tasks, 838

wrapped exceptions, 527

Invocation

base class constructors, 355–356

delegates, 629–632, 634–636

dynamic, 773–779

referenced packages and projects, 477–479

using statement, 499

Invoke() method

delegates, 630

dynamic invocation, 777

events, 161

IOException type, 520, 527

IOrderedEnumerable<T> interface, 677

IProducerConsumerCollection<T> interface, 939

IQueryable<T> interface

delegates, 620–621

query expressions, 708

queryable extensions, 694–695

"is a" relationships

abstract members, 361

classes, 388

derivation forms in, 339

"is a kind of" relationships, 257–258, 336

is operator

pattern matching example, 156–157

pattern matching overview, 365–371

positional pattern matching, 369

properties, 369–370

recursive pattern matching, 370–371

tuples, 368

type, var, and const pattern matching, 366–368

types with, 365–366

is { } property pattern, 156–157

IsCancellationRequested property, 846

IsCompleted property

multithreading, 828

parallel loops, 905

IsDefined() method, 445

ISerializable interface, 526

IsGenericType property, 780

IsInvalid member, 956

Iterations

loops, 170

parallel. See Parallel iterations

Iterators

compiling, 764–766

defining, 754

escaping, 763–764

multiple, 766–767

origin, 753–754

recursive, 762–763

states, 757–759

syntax, 755

yielding values from, 755–762

J

Jagged arrays

defining, 106

element assignment, 108–109

length, 110

Java language vs. C#

arrays, 101–102

exception specifiers, 518

filenames, 10

generics, 584–585

implicit overriding, 347

import directive, 210

inner classes, 328

Main(), 19

syntax similarities, 2–3

virtual methods, 346

JIT (just-in-time) compiler and jitting

CIL, 980

description, 34

thread synchronization, 920

Join() method

inner joins, 682–686

threads, 914

Join operations

inner joins, 682–686

outer joins, 688–691

overview, 678–682

Jump statements

break, 180–181

continue, 182–184

goto, 184–185

lambda expressions, 606

Just-in-time (JIT) compiler and jitting

CIL, 980

description, 34

thread synchronization, 920

K

KeyNotFoundException type, 741

Keys

dictionaries, 728–730, 740–741

equality, 743–744

sorted collections, 746

Keys property, 746

KeyValuePair<TKey, TValue> class, 741

Keywords

contextual, 766

as identifiers, 17

list of, 14

overview, 13–15

types, 47

L

Labels for switch statements, 177, 185

Lambda calculus, 608

Lambda expressions

asynchronous, 881–887

as data, 616–618

deferred execution, 674

expression trees, 616–623

filters, 715

internals, 610–611

lazy loading, 509–510

notes and examples, 605–606

outer variables, 611–616

overview, 587–588, 600–601, 604

predicates, 593

purpose, 608

statement, 601–604

LambdaExpression expression trees, 623

Language Integrated Query (LINQ)

anonymous types, 695–703

collections, 653–654

deferred execution, 672–676

delegates, 620

extension methods, 395

with IAsyncEnumerable, 875–877

parallel queries, 670–671, 905–911

query expressions. See Query expressions

Language interoperability, 35

Last in, first out (LIFO) collections, 747

LastIndexOf() method, 736

Late binding with metadata, 992

Latency

async/await syntax, 862–867

asynchronous example, 856–858

description, 814

multithreading for, 816–818

synchronous example, 854–856

WPF example, 889–891

Lazy initialization, 508–510

LazyCancellation task continuation option, 834

Leaf asynchronous task-returning method, 883–887

Left-associative operators, 125

Left outer joins, 679

Length

arrays, 109–110

strings, 66–67

Length property, 66

Less than signs (<)

generics, 540

overriding, 464, 466

pointers, 969

relational operators, 150

shift operators, 163–164

XML, 33

let clause, 717–718

Libraries

BCL. See Base Class Library (BCL)

classes, 472–475

creating, 473

dependencies, 10

referencing, 473–475

TPL. See Task Parallel Library (TPL)

Lifetime of captured outer variables, 612

LIFO (last in, first out) collections, 747

Line-based statements in Visual Basic vs C#, 20

#line directive, 187, 191

Line feeds

escape sequence, 58–59

newlines, 66

Line numbers, preprocessor directives for, 191

Linked lists, 749

LinkedList<T> class, 749

LinkedListNode<T> class, 749

LINQ. See Language Integrated Query (LINQ)

Liskov, Barbara, 753–754

List<T> class

overview, 731–733

searches, 736–738

Listeners for events, 627, 835–836

Lists

collections, 728–733

linked, 749

searching, 736–738

sorted, 745–747

Literal values

characters, 57

default, 50–51

overview, 49–50

strings, 59–61

Load() method, 273

Loading

with files, 270–273

lazy, 508–510

Local variables

anonymous types, 695–701

assigning values to, 24–25

declaring, 22–23

implicitly typed, 89–90

scope, 147–149

thread synchronization, 917–918

types, 23

working with, 25

Localized applications, Unicode standard for, 56

Locals, constant, 137–138

lock keyword

thread synchronization, 920–925

value types, 432–434

Locks

deadlocks, 821–823, 929–930

thread synchronization, 920–925, 931

value types, 432–434

Logical operators

Boolean, 151–153

overriding, 468

working with, 164–167

Lollipops, 395

Long-running tasks, 848–849

long type

characteristics, 46

conversions, 72

LongRunning task continuation option

delays, 849

description, 832

TPL performance, 900

Loop variables in lambda expressions, 614–616

Loops

for, 170–174

foreach, 174–175

parallel iterations, 895–905

while and do/while, 168–170

LowestBreakIteration property, 905

M

Machine code, compilation to, 34–35, 979–981

Main() method

async, 867

declaring, 18–19

description, 196–197

Java vs. C#, 19

multiple, 214–216

return values and parameters, 214–216

__makeref keyword, 17

Managed code, 34

Managed execution, 34–35

Manifests in CLI, 986–989

ManualResetEvent class, 934–937

ManualResetEventSlim class, 934–937

Many-to-many relationships in join operations, 679–680

Masks, logical operators for, 165

Matching caller variables with parameters, 218

Max() function, 693

MaxDegreeOfParallelism property, 904

MaybeNull attribute, 307, 309

MaybeNullWhen attribute, 307

Me keyword, 268

Mechanism relationships, 388

Members

abstract classes, 357–360

base class overriding, 353–355

class variables, 262

classes, 262

default interface, 398–400

dynamic invocation, 773–779, 781–782

explicit and implicit implementation, 386–390

static. See Static members

MemberwiseClone() method, 364

Memory

boxing, 428

finalizers, 495

generics, 543

multithreading complexity, 821

objects, 261

reference types, 82–84

Metadata

attributes, 306, 783–784

CIL, 991–992

CLI, 35

reflection, 770–773

XML, 33

Method groups for delegates, 596

Method invocations, query expressions as, 724–725

MethodCallExpression expression trees, 623

MethodImplAttribute, 925

MethodImplOptions class, 925

MethodInfo class

delegates, 598

dynamic invocation, 777

reflection, 788

Methods

anonymous, 600, 606–608, 610–611

arguments, 201

attributes, 799

call stacks, 216–217

called during construction, 348–349

casting in, 572–573

constraints, 571–572

constructors. See Constructors

declaring, 203–204

description, 18, 196–197

expression bodied, 208

extension, 321–322, 344, 394–395, 411–413

external, 948–949

generics, 568–573, 779–780

instance, 265–266

interface refactoring, 401

Main(), 214–216

names, 201

namespaces, 198–200, 209–211

overloading, 231–234

overview, 197–198

parameters. See Parameters

partial, 330–332

passing as arguments, 590–592, 596

publish-subscribe pattern, 640

recursion, 229–231

refactoring into, 204–205

resolution, 238–239

return values, 202, 206–208

scope, 201

vs. statements, 202–203

static members, 315–316

strings, 62–64

structs, 424

syntax, 18

this keyword, 269–270

type inferences, 569–571

types, 200–201

using directive, 209–214

virtual, 346–349

Microsoft .NET Framework

assemblies, 40

CLI implementation, 975–977

description, 39

garbage collection, 489–491

versioning, 40–42

Microsoft Silverlight compiler, 976

Min() function, 693

Minus signs (-)

compound assignment, 132

decrement operator, 133

delegates, 632–634, 650

identifier names, 16

overriding, 466–469

precedence, 124

referent member access, 970

subtraction, 123

unary operator, 122–123

Modules

attributes, 784–786

CLI, 986–989

dependencies, 992

Monitor class

locks, 432

thread synchronization, 918–920, 923–924

Mono compiler, 976

Mono .NET frameworks, 39

Move() method, 321

MoveNext() method

duck typing, 662

iterators, 758–759, 764

MoveNextAsync() method, 874

MTAs (multithreaded apartments), 945

Multicast delegates

description, 625

internals, 636–637

publish-subscribe pattern. See Publish-subscribe pattern

MulticastDelegate class

constraints, 558–559

internals, 597–598, 636–637

Multidimensional arrays, 102–106, 108

Multiple constraints, 561–562

Multiple inheritance

C++, 345

interfaces, 393

Multiple interfaces for single classes, 545–546

Multiple Iterators, 766–767

Multiple Main() methods, 214–216

Multiple .NET frameworks, 39–43

Multiple searches in lists, 737–738

Multiple selection for query expressions, 722–723

Multiple threads synchronization. See Thread synchronization

Multiple type parameters in generics, 549–551

Multiplication

binary operator, 123

compound assignment, 132

shift operator, 164

Multithreaded apartments (MTAs), 945

Multithreading

asynchronous tasks. See Asynchronous tasks

atomic operations, 819–820

canceling tasks, 843–849

deadlocks, 821–822

description, 816

disposability of tasks, 849

issues, 819–822

jargon, 815–816

long-running tasks, 848–849

memory model complexity, 821

overview, 813–815

performance considerations, 818–819

purpose, 816–818

race conditions, 820–821

Threading class, 850–851

Mutable value types, 434

Mutex class, 932–933

MutexSecurity class, 932–933

Mutual exclusion in deadlocks, 930

N

escape sequence, 58–59

new lines, 66

Name/value pairs for dictionaries, 656, 738, 741

Named arguments, 237–238

Named parameters

attributes, 794–795

changing names of, 237

nameof operator

arguments, 513

properties, 285

working with, 781–782

Names

ambiguity, 267–268

class definitions, 17

collisions, 198

constant values, 137

constructor parameters, 300

constructors, 294

enums, 439

fields, 281–282

identifiers, 15–16

indexers, 751

local variables, 24

methods, 197–198, 201

scope, 147–149

tuples, 95

type parameters, 544

variables, 418

Namespaces

aliasing, 213–214

defining, 481–484

methods, 198–200

nesting, 483

using directive, 64–65, 209–211

NaN (Not a Number) value, 131

Native code, 34

NDoc tool, 489

Negation operator (!), 153

Negative infinity value, 131

Negative numbers notation, 163

Negative zero value, 132

Nested items

classes, 326–328

delegates, 594–595

generic types, 552–553

if statements, 142–144

iterators, 762–763

namespaces, 210, 483

using directive, 211–212

.NET Compact Framework, 976

.NET Core, 975, 977–978

.NET frameworks

description, 993

garbage collection, 489–491, 983–984

multiple, 39–43

overview, 3

standard, 42–43

versioning, 40–42

.NET Micro Framework, 976

Net namespace, 483

.NET Native feature, 993

.NET Standard version, 978–979

new modifier in base class overriding, 349–353

new operator

arrays, 100, 103

constructors, 294–295

objects, 260–261

projections, 668–669

value types, 426–427

Newlines

escape sequence, 58–59

preprocessor directives, 186

variations, 66

NGEN tool, 980

No preemption condition in deadlocks, 930

NodeType property expression trees, 623

Non-nullable reference type properties, 303–306

None task continuation option, 831

Normal continuation, 829

Normal form for parameters, 227

Normalized data, 682

Not a Number (NaN) value, 131

NOT operators

inequality, 150–151

logical, 153

Notifications for thread synchronization, 928–929

NotImplementedException type, 248

NotNull attribute, 307

notnull constraints, 560

NotNullIfNotNull attribute, 307–308

NotNullWhen attribute, 307–308

NotOnCanceled task continuation option, 833

NotOnFaulted task continuation option, 832

NotOnRanToCompletion task continuation option, 832

nowarn preprocessor directive option, 190–191

NuGet packages

invoking, 477–479

references, 475–477

referencing, 473

Null character escape sequence, 57

Null-coalescing operator, 157–160

Null-conditional operator

dereferencing operations, 513

null checks, 86, 630

thread synchronization, 928

working with, 158–161

Null-forgiving operator (!), 160–161, 634

null modifier, 308–309

null references, dereferencing, 85

null values

checking for, 85–86

collections, 753

dereferencing, 87

pointers, 964–965

programming with, 155–157

publish-subscribe pattern, 630–632

strings, 69–70

types allowing, 84–85

Nullable attributes, 306–308

#nullable directive, 88, 187, 193

nullable modifier

reference types, 71

strings, 70

type declarations, 84–85

Nullable reference types

default values, 548

nullable modifier, 84

overview, 70–71, 87–89

preprocessor directives, 193

Nullable values

array initial values, 104

default values, 548

description, 86

example, 538–539

struct constraints, 561

Nullable<T> type, 87, 308, 561

NullReferenceException type

delegates, 644

dereferencing null values, 85, 87, 513

description, 248

reference type nullability, 88

thread synchronization, 928

Numeric types

decimal, 49

floating-point, 47–49

hexadecimal notation, 52–54

integers, 46–47

literal values, 49–50

round-trip formatting, 54–55

O

Object class

derivation from, 363–365

dynamic objects, 805–806

Object-oriented programming

encapsulation, 257

inheritance, 257–259

overview, 256–257

polymorphism, 259

Objects. See also Classes

associated data, 314

CTS, 990

defined, 260

dynamic programming, 801–802

expression trees, 618–619

filtering, 666–667

identity vs. equality, 456–460

initializers, 296–297

member overriding, 451–464

resurrecting, 507–508

ObsoleteAttribute, 797, 799–800

OfType<T>() operator, 693

One-to-many relationships

example, 680–681

inner joins, 686–688

OnlyOnCanceled task continuation option, 832

OnlyOnFaulted task continuation option, 833

OnlyOnRanToCompletion task continuation option, 833

Operands

description, 122

evaluation, 126

Operational polymorphism, 232

OperationCanceledException type, 908, 911

operator keyword, 466

Operators

assignment, 24–25

associativity, 124–125

binary, 123–124

bitwise, 162–167, 181–182

characters in arithmetic operations, 127–128

compound assignment, 132, 468

concatenation, 126–127

conditional, 154–155

constant expressions and locals, 137–138

constraints, 567–568

decrement, 133–137

delegates, 633–634

description, 121

evaluation, 125

floating-point equality, 129–132

increment, 133

logical, 151–153, 164–167

with null, 155–157

null-coalescing, 157–158

null-conditional, 158–161

null-forgiving, 160–161

overriding, 464–472

overview, 122

precedence, 124–125, 194

relational and equality, 150–151

shift, 163–164

special floating-point characteristics, 128–129

thread-safe, 137

unary, 122–123

Optional parameters, 234–238

OR operations

bitwise operators, 164–165

constraints, 568

enums, 444–445

logical operators, 151–152

orderby clause, 716–717

OrderBy() method, 676–678

OrderByDescending() method, 678

Ordering collections, 735–736

out parameters

conversions, 78

properties, 291

out type parameter modifier, 575–577

Outer joins, 679, 688–691

Outer variables in lambda expressions, 611–616

OutOfMemoryException type, 514, 520

Output, console, 28–33

Output parameters, 220–223

Overflow, buffer

C# vs. C++, 109–110

managed execution, 986

type safety, 35, 984

unsafe code, 962

Overflow of integers, 528–530

OverflowException type, 73, 529

Overloading

constructors, 298–300

methods, 231–234

override keyword, 349–351

Overriding

assignment operators, 468

Base class. See Base class overriding

binary operators, 466–467

comparison operators, 464–465

conversion operators, 470–472

Equals(), 455–464

GetHashCode(), 453–455, 463–464

logical operators, 468

methods, 349–351

object members, 451–464

operators, 464–472

ToString(), 452–453

unary operators, 468–470

P

P/Invoke. See Platform Invoke (P/Invoke)

Packages, invoking, 477–479

Pair<T> type

iterators, 760, 764

struct vs. class, 763

Parallel class, 897–898

Parallel iterations

loops, 895–905

overview, 895

performance, 899–900

PLINQ queries, 905–911

Parallel LINQ (PLINQ), 814

canceling queries, 908–911

parallel queries, 905–911

running queries, 670–671, 905–908

Parallel loops

breaking, 904–905

canceling, 901–903

exception handling, 900–901

for, 895–898

foreach, 898–899

options, 903–904

performance, 899–900

Parallel programming, 818

ParallelEnumerable class, 670, 906–907

ParallelLoopResult class, 905

ParallelLoopState class, 905

ParallelOptions class, 904

ParallelQuery<T> class, 911

ParameterExpression expression trees, 623

Parameterized generic types, 539–540

Parameters

anonymous methods, 607–608

arrays, 226–229, 552

catch blocks, 516

constraints. See Constraints

constructors, 294, 299–300

declaring, 205

events, 645

extension methods, 322

finalizers, 495

generics, 542, 544–545, 549–551

in, 223

indexers, 752

lambda expressions, 606

Main(), 214–216

matching caller variables with, 218

method resolution, 238–239

methods, 197, 201

optional, 234–238

out, 220–223

reference types, 218–220

return by reference, 223–225

statement lambdas, 602–604

types, 949–951

value, 217–220

Parent types, 258, 336

Parentheses ()

casts, 72, 339

collection initializers, 655

declaration lists, 205

lambda expressions, 603

logical operators, 152

operator precedence, 125

query expressions, 723

tuples, 92

Parse() method

conversions, 76, 79

enum, 442

FlagsAttribute, 796–797

metadata, 772–773

Parsing types, 77–79

Partial classes

defining, 329–330

methods, 330–332

Partial interface refactoring, 405

Partial methods

description, 208

interface refactoring, 405

PascalCase

description, 15–16

field names, 281

interfaces, 379

namespaces, 482

properties, 282

tuples, 95

type names, 17

Pass-by-reference, 640

Passed by reference variables, 220

Passed by value arguments, 217

Passing

anonymous methods, 607

arrays, 226

command-line arguments, 215

delegates, 509, 597–598, 604

instances, 419

method return values, 202

methods as arguments, 590–592, 596

null values, 85

out parameters, 220

read-only references, 223

this keyword, 270, 426

values to methods, 82, 217

variables by reference, 219

variables to methods, 197

Pattern matching

is operator, 365–371

with null, 156

polymorphism, 373

positional, 369

properties, 369–370

recursive, 370–371

switch statements, 179, 371–372

tuples, 368

types, var, and const, 366–368

Peek() method, 747

Percent signs (%)

compound assignment, 132

overriding, 466, 468

precedence, 124

remainder operation, 123

Performance

CLI, 985–986

hash codes, 454

multithreading, 818–819

parallel iterations, 899–900

Periods (.)

fully qualified method names, 198

nested namespaces, 210, 483

null-conditional operator, 158

Pi calculations, 895–898

Platform interoperability

delegates, 971–972

overview, 947–948

P/Invoke, 948–960

pointers and addresses, 960–970

Platform Invoke (P/Invoke)

description, 948

error handling, 953–955

external functions, 948–949, 956–958

function pointers, 960

parameter data types, 949–951

references, 951–952

SafeHandle, 955–956

sequential layout, 952–953

wrappers, 959

Platform portability

CLI, 985

managed execution, 35

preprocessor directives for, 188

PLINQ. See Parallel LINQ (PLINQ)

Plus signs (+)

addition, 123

characters, 127

compound assignment, 132

delegates, 633–634, 650

increment operator, 133

overriding, 464, 466–469

precedence, 124

strings, 126–127

unary operator, 122–123

Pointers

assigning, 964–965

declaring, 963–964

dereferencing, 968–970

fixing data, 965–967

function, 960

P/Invoke, 951–952

vs. ref, 951

referent member access, 970

stacks, 967–968

unsafe code, 961–963

Polling tasks, 826–828

Polyfill code, 526

Polymorphism

abstract classes, 361–363

interfaces, 380–384