Index
A
a escape sequence, 70
Abstract accessors, 38, 490–491
Abstract classes
and interfaces, 583–584
overview, 408–409
Abstract events, 497–498
Abstract indexers, 499
Access and accessibility
array elements, 556
containing types, 438–440
events, 220
accessibility domains, 97–100
constraints, 102–104
declared accessibility, 95–97
interface, 567–569
pointer, 634–635
in primary expressions, 242–246
protected, 100–102
nested types, 436–440
pointer elements, 635–636
primary expression elements, 253–255
Accessors
attribute, 610
event, 496–497
Acquire semantics, 450
Acquisition in using statement, 388
add accessors
attributes, 610
Add method, 35
AddEventHandler method, 497
Addition operator
described, 12
uses, 290–292
Address-of operator, 636–637
Addresses
fixed variables, 640–645
after state for enumerator objects, 525–527
Alert escape sequence, 70
Aliases
for namespaces and types, 395–400
qualifiers, 404–406
uniqueness, 405–406
Alignment enumeration, 48–49
Alloc method, 650
Allocation, stack, 648–649
AllowMultiple parameter, 604
Ambiguities
grammar, 246
in query expressions, 326
for addresses, 630
in assignment operators, 339
definite assignment rules, 167–168
for logical operators, 307–311
for pointers, 636–637
in preprocessing expressions, 77
AND operators, 12
Angle brackets (<>) for type arguments, 141
bodies, 318
conversions, 193–194
evaluation to delegate types, 146–148, 195
evaluation to expression tree types, 196
implementation example, 196–199
implicit, 179
definite assignment rules, 171
delegate creation, 51–52
evaluation of, 324
expressions, 146–147, 280, 314–317
outer variables, 320–324
overloaded, 319–320
signatures, 317–318
Anonymous objects, 271–273
AppendFormat method, 27
Applicable function members, 232–233
Application domains, 87
Applications, 4
startup, 86–87
termination, 88–89
Apply method, 50
Arguments, 24. See also Parameters
command-line, 87
for function members, 221–224
type, 141–143
type inference, 224–231
Arithmetic operators, 285
addition, 290–292
division, 287–288
multiplication, 285–287
pointer, 638–639
remainder, 288–290
shift, 296
subtraction, 292–295
ArithmeticException class, 287, 601
Arrays and array types, 6–7, 10, 137
conversions, 177
creating, 555–556
with foreach, 372
IList interface, 554–555
new operator for, 43, 45, 266–269
overview, 43–45
and pointers, 632–633, 642–643
rank specifiers, 553–554
syntactic grammar, 715–716
ArrayTypeMismatchException class, 340–341, 557, 601
as operator, 305–306
Assemblies, 4–5
Assignment
in classes vs. structs, 541
definite. See Definite assignment
fixed size buffers, 648
compound, 342–343
event, 344
simple, 340–342
Associativity of operators, 206–208
Asterisks (*)
assignment operators, 339
multiplication, 285–287
transparent identifiers, 335
At sign characters (@) for identifiers, 62–64
Atomicity of variable references, 172
Attributes, 603
compilation of, 614
compilation units, 393
instances, 613–614
for interoperation, 621
overview, 53–54
parameters for, 605–607
partial types, 421
reserved, 615
AttributeUsage, 615
Conditional, 616–619
Obsolete, 620–621
sections for, 607
specifications, 607–613
syntactic grammar, 718–720
AttributeUsage attribute, 603–606, 615
Automatic memory management, 116–121
Automatically implemented properties, 481, 486–487
B
escape sequence, 70
Backslash characters ()
for characters, 70
escape sequence, 70
for strings, 72
Backtick character (`), 72
Banker’s rounding, 132
Base access, 256–257
Base classes, 21–22
partial types, 423
specifications for, 411–414
type parameter constraints, 419
Base interfaces
inheritance from, 562–564
partial types, 423
Base types, 217
before state for enumerator objects, 525–527
Better conversions, 234–235
Better function members, 233–234
Binary operators, 206
declarations, 506–507
in ID string format, 671
lifted, 214
numeric promotions, 212–213
overload resolution, 210–211
overloadable, 208–209
Bind method, 46
Binding, name, 428–429
BitArray class, 501–502
Bitwise complement operator, 282
Blocks
in declarations, 90–91
definite assignment rules, 158
exiting, 373
in grammar notation, 56
invariant meaning in, 241–242
in methods, 477
reachability of, 349
in statements, 350–351
for unsafe code, 624
Bodies
classes, 420
interfaces, 564
struct, 538
Boolean values
expressions, 346
literals, 66
operators
conditional logical, 310
equality, 300
logical, 308–309
in struct example, 549–551
Bound types, 143
Box class, 473
Boxed instances, invocations on, 237
in classes vs. structs, 542–544
break statement
definite assignment rules, 161
example, 16
for for statements, 367–368
overview, 374
for switch, 361–362
for while, 365
Brittle base class syndrome, 29, 249
Brittle derived class syndrome, 249, 253
Buffers, fixed-size
declarations, 645–647
definite assignment, 648
in expressions, 647–648
Bugs. See Unsafe code
byte type, 8
C
<c> tag, 656
Cache class, 386
Callable entities, 591
Candidate user-defined operators, 211
Captured outer variables, 320–321
Carets (^)
in assignment operators, 339
for logical operators, 307–308
Carriage-return characters
escape sequence, 70
as line terminators, 58–59
Case labels, 361–364
Cast expressions, 284–285
catch blocks
definite assignment rules, 163–164
for exceptions, 600–601
throw statements, 378–379
try statements, 380–384
char type, 129
Character literals, 69–70
Characters, 7
checked statement
definite assignment rules, 158
example, 17
overview, 385
in primary expressions, 276–279
Classes
accessibility, 20
bodies, 420
constants for, 443–445
constructors for, 36
instance, 510–517
static, 518–520
declarations, 407
base specifications, 411–414
bodies, 420
modifiers, 407–410
partial type, 410–411
type parameter constraints, 414–420
type parameters, 411
defined, 407
events in, 38–39
accessors, 496–497
declaration, 491–494
field-like, 494–495
instance and static, 497
fields in, 22–23
declarations, 445–447
initializing, 451–452
read-only, 448–450
static and instance, 447–448
variable initializers, 452–455
volatile, 450–451
function members in, 34–40
instance variables in, 150
interface implementation by, 47
iterators. See Iterators
access modifiers for, 434
constituent types for, 434
constructed types, 431–432
inheritance of, 432–433
instance types, 431
nested types for, 436–442
new modifier for, 433–434
reserved names for, 440–442
static and instance, 434–435
methods in, 24–34
abstract, 473–474
bodies, 477–478
declaration, 455–457
extension, 475–477
external, 474–475
parameters, 458–465
partial, 475
sealed, 472–473
static and instance, 466
virtual, 466–469
operators in, 40
binary, 506–507
conversion, 507–510
declaration, 503–505
unary, 505–506
overview, 18
partial types. See Partial types
in program structure, 4
properties in, 37–38
accessibility, 487–489
accessors for, 480–486
automatically implemented, 486–487
declarations, 478–479
static and instance, 479
vs. structs, 539–547
syntactic grammar, 706–714
type parameters, 20–21
Classifications, expression, 203–205
Click events, 494
Closed types, 143
<code> tag, 656
Collections
for foreach, 369
initializers, 264–266
Colons (:)
alias qualifiers, 404
grammar productions, 56
interface identifiers, 562
type parameter constraints, 415
Color enumeration, 48, 585–588
Color struct, 245
COM, interoperation with, 621
Command-line arguments, 87
Commas (,)
attributes, 607
collection initializers, 265
ID string format, 667
interface identifiers, 562
object initializers, 262
Comments, 653
documentation file processing, 666–671
example, 672–677
overview, 653–655
tags, 655–665
Commit method, 81
Common types for type inference, 231
CompareExchange method, 532
booleans, 300
decimal numbers, 299–300
delegates, 303–304
enumerations, 300
floating point numbers, 298–299
integers, 298
pointers, 639
reference types, 301–303
strings, 303
Compatibility of delegates and methods, 595
Compilation
attributes, 614
just-in-time, 5
Compilation directives, 79–83
Compilation symbols, 76–77
Compilation unit productions, 57
Compilation units, 55, 393–394
Compile-time type of instances, 29, 466
Complement operator, 282
Component-oriented programming, 1–2
Compound assignment, 342–343
Concatenation, string, 291–292
Conditional attribute, 616–619
Conditional classes, 619
Conditional compilation directives, 79–83
Conditional compilation symbols, 76–77
Conditional logical operators, 12, 309–311
Conditional methods, 616–618
Conditional operator, 12, 313–314
Constant class, 30–31
Constants, 34
declarations, 356–357, 443–445
enums for. See Enumerations and enum types
static fields for, 448–449
versioning of, 449
Constituent types, 434
Constraints
accessibility, 102–104
constructed types, 144–145
partial types, 422–423
type parameters, 414–420
Constructed types, 141–142
bound and unbound, 143
constraints, 144–145
members, 431–432
open and closed, 143
type arguments, 142–143
Constructors, 34
for classes, 36
for classes vs. structs, 546–547
in ID string format, 669
instance. See Instance constructors
invocation, 221
Contexts
for attributes, 609–611
unsafe, 624–627
Contextual keywords, 65
continue statement
definite assignment rules, 161
for do, 366
example, 16
for for statements, 367
overview, 375
for while, 365
Contracts, interfaces as, 561
Control class, 496–497
Control-Z character, 59
Conversions, 173
anonymous functions, 146–148, 192–199, 317–318
constant expression, 178–179
explicit, 180–188
expressions, 284–285
function members, 234–235
identity, 174
implicit, 173–179
standard, 188
user-defined, 191–193
method groups, 200–202
null literal, 176
as operator for, 305–306
for pointers, 631–632
standard, 188
user-defined. See User-defined conversions
Convert class, 183
Copy method, 650–651
Counter class, 485
Counter struct, 543
CountPrimes class, 502
Covariance, array, 177, 556–557
cref attribute, 654
Critical execution points, 121
.cs extension, 2
Curly braces ({})
collection initializers, 265
grammar notation, 56
object initializers, 262
Currency type, 133
Current property, 527
Customer class, 426–428
D
Database structure example
boolean type, 549–551
integer type, 546–548
DBBoolean struct, 549–551
DBInt struct, 546–548
Decimal numbers and type, 7–8, 131–133
addition, 291
comparison operators, 299–300
division, 288
multiplication, 287
negation, 281
remainder operator, 290
subtraction, 293–294
Declaration directives, 78–79
Declaration space, 89
Declaration statements, 353–356
Declarations
classes, 407
base specifications, 411–414
bodies, 420
modifiers, 407–410
partial type, 410–411
type parameter constraints, 414–420
type parameters, 411
definite assignment rules, 159
delegates, 592–594
events, 491–494
fields, 445–447
fixed-size buffers, 645–647
indexer, 498–503
instance constructors, 510–511
interfaces, 561–564
methods, 455–457
operators, 503–505
overview, 89–92
parameters, 458–459
pointers, 628
properties, 478–479
property accessors, 480
static constructors, 518–520
struct members, 539
structs, 537–538
Declared accessibility
nested types, 436–437
overview, 95–97
Decrement operators
pointers, 637–638
postfix, 257–259
prefix, 282–284
default expressions, 126
Defaults
constructors, 125–126, 515–516
switch statement labels, 360–361
classes vs. structs, 541–542
expressions, 279–280
Defining partial method declarations, 425–426
Definite assignment, 27, 149, 155–156
fixed size buffers, 648
initially assigned variables, 156
initially unassigned variables, 157
rules for, 157–171
Degenerate query expressions, 329
Delegate class, 591
Delegates and delegate type, 6–10, 137, 591
compatible, 595
declarations, 592–594
equality, 303–304
instantiation, 595–596
members of, 94
new operator for, 269–271
overview, 49–52
removing, 294
syntactic grammar, 718
Delimited comments, 59–60, 653–654
Dependence
on base classes, 413
in structures, 540
type inference, 227
Depends on relationships, 413, 540
for classes vs. structs, 547
exceptions for, 601
garbage collection, 117–121
in ID string format, 669
member names reserved for, 442
members, 19
Diagnostic directives, 83
Digit struct, 510
Dimensions, array, 9, 44, 553, 557–558
Direct base classes, 412–413
Directives
preprocessing. See Preprocessing directives
using. See Using directives
Directly depends on relationships, 413, 540
Disposal in using statement, 388
Dispose method, 52
for enumerator objects, 527, 535–536
for resources, 387
Divide method, 25–26
DivideByZeroException class, 287–288, 599, 601
Division operator, 287–288
DllImport attribute, 475
DLLs (Dynamic Link Libraries), 475
do statement
definite assignment rules, 161
example, 15
overview, 366
Documentation comments, 653
documentation files for, 653, 666
ID string examples, 667–672
ID string format, 666–668
example, 672–677
overview, 653–655
tags for, 655–665
XML files for, 653–654, 674–677
Documentation generators, 653
Documentation viewers, 653
Domains
accessibility, 97–100
application, 87
Double quotes (")
characters, 70
strings, 70
Dynamic Link Libraries (DLLs), 475
Dynamic memory allocation, 649–651
E
ECMA-334 standard, 1
EditBox class, 46–47
Effective base classes, 419
Effective interface sets, 419
Elements
foreach, 369
pointer, 635–636
primary expression, 253–255
Ellipse class, 473
Embedded statements and expressions
general rules, 165–166
in grammar notation, 56
Empty statements, 351–352
Encompassed types, 190
Encompassing types, 190
End points, 348–349
#endregion directive, 84
Entity class, 28–29
Entry class, 4–5
Entry points, 87
Enumerable interfaces, 524
Enumerable objects for iterators, 528
Enumerations and enum types, 585, 589
addition of, 291
comparison operators, 300
conversions
explicit, 183
implicit, 175
declarations, 585–586
logical operators, 308
modifiers, 586
overview, 48–49
subtraction of, 294
syntactic grammar, 717–718
types for, 133
values and operations, 590
Enumerator interfaces, 524
Enumerator objects for iterators, 525–527
Enumerator types for foreach, 369
Equal signs (=)
assignment operators, 339
comparisons, 297
operator ==, 40
pointers, 639
preprocessing expressions, 77
Equality operators
boolean values, 300
delegates, 303–304
lifted, 214
and null, 304
reference types, 301–303
strings, 303
Equals method
on anonymous types, 273
DBBool, 551
DBInt, 548
List, 35
with NaN values, 299
Point, 673
#error directive, 83
Error property, 486
Error strings in ID string format, 666
Escape sequences
characters, 70
lexical grammar, 681
strings, 70
unicode character, 61–62
Evaluate method, 31
Evaluation of user-defined conversions, 189–191
Events, 4
access to, 220
accessors, 496–497
assignment operator, 344
declarations, 491–494
example, 36
field-like, 494–495
in ID string format, 666, 670–671
instance and static, 497
interface, 566–567
member names reserved for, 442
overview, 38–39
Exact parameter type inferences, 228
<example> tag, 657
Exception class, 378, 381, 599–600
Exception propagation, 379
<exception> tag, 657
Exception variables, 381
Exceptions
causes, 599
classes for, 601–602
for delegates, 596
throwing, 378–380
try statement for, 380–384
Exclamation points (!)
comparisons, 297
definite assignment rules, 169
logical negation, 281
operator !=, 40
pointers, 639
preprocessing expressions, 77
Execution
instance constructors, 513–515
order of, 121
Exiting blocks, 373
Expanded form function members, 233
Explicit base interfaces, 562
Explicit conversions, 180
enumerations, 183
nullable types, 183–184
numeric, 180–183
reference, 184–185
standard, 188
type parameters, 186–187
unboxing, 185
Explicit interface member implementations, 47, 571–574
explicit keyword, 507–510
Explicit parameter type inferences, 227
Expression class, 30–32
Expression statements, 14, 159, 357–358
Expressions, 203
anonymous function. See Anonymous functions
boolean, 346
cast, 284–285
classifications, 203–205
definite assignment rules, 165–170
fixed-size buffers in, 647–648
function members
argument lists, 221–224
categories, 217–221
invocation, 236–237
overload resolution, 231–235
type inference, 224–231
member lookup, 214–217
operators for, 206
arithmetic. See Arithmetic operators
assignment, 339–344
logical, 307–311
numeric promotions, 211–213
overloading, 208–211
precedence and associativity, 206–208
relational, 297
shift, 295–296
unary, 280–285
overview, 10–13
pointers in, 633–640
preprocessing, 77–78
primary. See Primary expressions
query, 324–325
ambiguities in, 326
patterns, 337–338
translations in, 326–337
syntactic grammar, 691–700
values of, 205
Extensible Markup Language (XML), 653–654, 674–677
Extension methods
example, 475–477
invocation, 250–253
extern aliases, 395–396
External constructors, 510, 518
External destructors, 521
External events, 493
External indexers, 501
External methods, 474–475
External operators, 504
External properties, 479
F
f escape sequence, 70
False value, 66
Field-like events, 494–495
Fields, 4
declarations, 445–447
example, 34
in ID string format, 666, 668–669
overview, 22–23
static, 447–448
variable initializers, 452–455
volatile, 450–451
Fill method, 556
Filters, 384
Finalize method, 522
finally blocks
definite assignment rules, 163
for exceptions, 600
with goto, 376–377
with try, 380–384
Fixed-size buffers
declarations, 645–647
definite assignment, 648
in expressions, 647–648
Fixed variables, 630–631
Fixing type inferences, 228
Floating point numbers
addition, 290–291
comparison operators, 298–299
division, 287–288
multiplication, 286
negation, 281
remainder operator, 289
subtraction, 293
for statement
definite assignment rules, 161
example, 15
overview, 366–368
foreach statement
definite assignment rules, 164
example, 15
overview, 368–372
Form feed escape sequence, 70
Forward declarations, 5
Fragmentation, heap, 642
Free method, 650–651
FromTo method, 530–531
Fully qualified names
described, 115–116
interface members, 569–570
nested types, 436
argument lists, 221–224
in classes, 34–40
invocation, 236–237
overload resolution, 231–235
overview, 217–221
type inference, 224–231
Function pointers, 591
Functional notation, 209
Functions, anonymous. See Anonymous functions
G
Garbage collection, 1
at application termination, 89
for destructors, 40
in memory management, 116–121, 155
and pointers, 627
for variables, 630
Generic classes and types, 21, 123
anonymous objects, 273
constraints, 144, 146, 414–417, 422
delegates, 194
instance type, 431
interfaces, 574
member lookup, 215
overloading, 235
overriding, 470
query expression patterns, 337
signatures, 24
static fields, 22
type inferences, 224–226, 229–230
unbound, 141–143
Generic interface, 554–555
get accessors, 490
for attributes, 610
defined, 37
working with, 480–486
GetEnumerator method
for foreach, 369–370
for iterators, 528–534
GetEventHandler method, 497
GetHashCode method
on anonymous types, 273
DBBool, 551
DBInt, 548
GetHourlyRate method, 32
GetNextSerialNo method, 28
GetProcessHeap method, 651
GetScriptDescriptors method, 523
GetScriptReferences method, 523
Global declaration space, 89
Global namespace, 93
goto statement
definite assignment rules, 161
example, 16
working with, 375–377
Governing types of switch statements, 360, 363
Grammars, 55
ambiguities, 246
lexical. See Lexical grammar
notation, 55–57
syntactic. See Syntactic grammar
for unsafe code, 720–723
Greater than signs (>)
assignment operators, 339
comparisons, 297
shift operators, 295–296
Grid class, 502–503
group clauses, 325, 327–328, 334–335
H
HasValue property, 134
Heap
accessing functions of, 649–651
fragmentation, 642
HeapAlloc method, 651
HeapFree method, 651
HeapReAlloc method, 651
HeapSize method, 651
Hello, World program, 2–3
Hello class, 82
HelpAttribute class, 53, 605–606
HelpStringAttribute class, 612
Hexadecimal escape sequences
for characters, 70
for strings, 73
Hiding
inherited members, 90, 111–112, 433
in multiple-inheritance interfaces, 569
properties, 483
in scope, 106
Hindley-Milner-style algorithms, 226
Horizontal tab escape sequence, 70
I
IBase interface, 568–569, 578, 583
ICloneable interface, 570, 573, 577–578
IComboBox interface, 46, 563–564
IComparable interface, 570
IControl interface, 46–47, 563
implementations, 570–571
inheritance, 580–581
mapping, 578–580
member implementations, 573–574
member names, 569–570
reimplementations, 581–582
ICounter interface, 567
ICounter struct, 544
ID string format
for documentation files, 666–668
examples, 667–672
IDataBound interface, 46–47
Identical simple names and type names, 245
Identifiers
lexical grammar, 681–682
rules for, 62–64
Identity conversions, 174
IDerived interface, 578–579
IDictionary interface, 571
IDisposable interface, 120, 371, 387–390, 572
IDouble interface, 568
IEnumerable interface, 369–370, 523–524, 528
IEnumerator interface, 524
if statement
definite assignment rules, 159
example, 14
working with, 358–359
IForm interface, 578
IInteger interface, 568
IL (Intermediate Language) instructions, 5
IList interface, 554–555, 567, 571
IListBox interface, 46, 563, 579
IListCounter interface, 567
IMethods interface, 582–583
ImpersonationScope class, 52
Implementing partial method declarations, 425–426
Implicit conversions, 173–174
anonymous functions and method groups, 179
boxing, 178
constant expression, 178–179
enumerations, 175
identity, 174
null literal, 176
nullable, 176
numeric, 174–175
operator for, 507–510
standard, 188
type parameters, 179
implicit keyword, 507–510
Implicitly typed array creation expressions, 267
Implicitly typed iteration variables, 368
Implicitly typed local variable declarations, 354–355
Importing types, 400–402
In-line methods, 51
In property, 486
Inaccessible members, 95
Increment operators
for pointers, 637–638
postfix, 257–259
prefix, 282–284
IndexerName Attribute, 621
Indexers
declarations, 498–503
example, 35
in ID string format, 670
interface, 567
member names reserved for, 442
overview, 38
IndexOf method, 33–34
IndexOutOfRangeException class, 254, 601
Indices, array, 43
Indirection, pointer, 630, 634
Inference, type, 224–231
infoof operator, 274
Inheritance
from base interfaces, 562–564
in classes, 22, 92–93, 432–433
in classes vs. structs, 541
hiding through, 90, 111–112, 433
interface, 580–581
parameters, 605
properties, 483
Initializers
in for statements, 367
instance constructors, 512–513
stack allocation, 648–649
Initially assigned variables, 149, 156
Initially unassigned variables, 149, 157
Inlining process, 485
InnerException property, 600
Input production, 57
Input types in type inference, 227
Instance constructors, 36
declarations, 510–511
default, 515
execution, 513–515
initializers, 512–513
invocation, 221
optional parameters, 517
private, 516–517
Instance events, 497
Instance fields
class, 447–448
example, 22–23
read-only, 448–450
Instance members
class, 434–435
protected access for, 100–102
Instance methods, 24, 28–29, 466
Instance properties, 479
Instance types, 431
Instance variables, 150, 447–448
Instances, 18
attribute, 613–614
type, 135
Instantiation
delegates, 595–596
local variables, 321–324
int type, 8
Integers
addition, 290
comparison operators, 298
division, 287
literals, 66–68
logical operators, 307
multiplication, 286
negation, 281
remainder, 289
in struct example, 546–548
subtraction, 293
interface keyword, 561
Interface sets, 419
base, 562–564
bodies, 564
declarations, 561–564
enumerable, 524
enumerator, 524
generic, 574
implementations, 570–571
abstract classes, 583–584
base classes, 414
explicit member, 571–574
generic methods, 575–576
inheritance, 580–581
mapping, 576–580
reimplementation, 581–583
uniqueness, 574–575
inheritance from, 562–564
access to, 567–569
events, 566–567
fully qualified names, 569–570
indexers, 567
methods, 565–566
properties, 566
modifiers, 562
overview, 46–47
partial types, 423
struct, 538
syntactic grammar, 716–717
Intermediate Language (IL) instructions, 5
Internal accessibility, 20, 95
Interning, 73
Interoperation attributes, 621
IntToString method, 649
IntVector class, 506
InvalidCastException class, 141, 185, 306, 601
InvalidOperationException class, 134, 533
Invariant meaning in blocks, 241–242
Invocation
function members, 236–237
instance constructors, 221
methods, 218
operators, 221
Invocation expressions, 166, 247–253
is operator, 304–305
isFalse property, 550
isNull property
DBBool, 550
DBInt, 547
ISO/IEC 23270 standard, 1
isTrue property, 550
Iteration statements, 364
do, 366
for, 366–368
foreach, 368–372
while, 365
Iteration variables in foreach, 368
Iterators, 522–524
enumerable interfaces, 524
enumerable objects for, 528
enumerator interfaces, 524
enumerator objects for, 525–527
implementation example, 528–536
yield type, 524
ITextBox interface, 46, 563, 569–571, 574, 579
J
Jagged arrays, 44
JIT (Just-In-Time) compiler, 5
Jump statements, 373–374
break, 374
continue, 375
goto, 375–377
return, 377–378
throw, 378–380
Just-In-Time (JIT) compiler, 5
K
KeyValuePair struct, 542
Keywords
lexical grammar, 682
list, 65
Kleene operators, 56
L
Label class, 484–485
Label declaration space, 90–91
Labeled statements
for goto, 375–377
overview, 352–353
Left-associative operators, 207
Left shift operator, 295–296
Length of arrays, 43, 553, 558–559
Less than signs (<)
assignment operators, 339
comparisons, 297
pointers, 639
shift operators, 295–296
let clauses, 329–334
identifiers, 681–682
keywords, 682
literals, 683–685
operators and punctuators, 685
preprocessing directives, 686–689
tokens, 681
unicode character escape sequences, 681
Lexical structure, 55
grammars, 55–57
lexical. See Lexical grammar
syntactic. See Syntactic grammar
lexical analysis, 57–61
preprocessing directives, 74–76
conditional compilation, 76–77, 79–83
declaration, 78–79
diagnostic, 83
line, 84–85
pragma, 85–86
preprocessing expressions, 77–78
region, 83–84
programs, 55
tokens, 61
identifiers, 62–64
keywords, 65
literals, 65–74
operators, 74
unicode character escape sequence, 61–62
Lifted conversions, 189
Lifted operators, 213–214
#line directive, 84–85
#line default directive, 85
Line directives, 84–85
Line-feed characters, 59
#line hidden directive, 85
Line-separator characters, 59
List class, 34–40
<list> tag, 658–659
ListChanged method, 39
Lists, statement, 350–351
Literals, 65–66
boolean, 66
character, 69–70
in constant expressions, 344
conversions, 176
integer, 66–68
lexical grammar, 683–685
null, 74
in primary expressions, 238
real, 68–69
simple values, 127
string, 71–73
Local constant declarations, 14, 356–357
Local variable declaration space, 91
Local variables, 153–154
instantiation, 321–324
in methods, 27–28
scope, 109–110
lock statement
definite assignment rules, 165
example, 17
overview, 385–387
Logical operators, 307
AND, 12
for boolean values, 308–309
conditional, 309–311
for enumerations, 308
for integers, 307
negation, 281–282
OR, 12
shift, 296
XOR, 12
LoginDialog class, 493–494
long type, 8
Lookup, member, 214–217
Lower-bound type inferences, 228
lvalues, 171
M
Main method
for startup, 86–87
for static constructors, 518–520
Mappings
interface, 576–580
pointers and integers, 632
accessibility domains, 97–100
constraints, 102–104
declared accessibility, 95–97
interface, 567–569
pointer, 634–635
in primary expressions, 242–246
protected, 100–102
accessibility of, 20
access modifiers for, 434
constituent types, 434
constructed types, 431–432
inheritance of, 432–433
instance types, 431
nested types, 436–442
new modifier for, 433–434
reserved names for, 440–442
static and instance, 434–435
delegate, 94
function. See Function members
inherited, 90, 92–93, 111–112, 432–433
access to, 567–569
events, 566–567
explicit implementations, 47, 571–574
fully qualified names, 569–570
indexers, 567
methods, 565–566
properties, 566
lookup, 214–217
partial types, 424
pointer, 634–635
Memory
automatic management of, 116–121, 155
dynamic allocation of, 649–651
Memory class, 650–651
Message property, 600
Metadata, 5
Method group conversions
implicit, 179
overview, 200–202
type inference, 230–231
conditional, 616–618
declarations, 455–457
extension, 475–477
external, 474–475
in ID string format, 666, 669–670
interface, 565–566
in List, 35
overloading, 32–34
parameters, 24–27
arrays, 462–465
declarations, 458–459
output, 461–462
reference, 460–461
value, 459–460
sealed, 472–473
Minus (-) operator, 281
Minus signs (-)
assignment operators, 339
decrement operator, 257–259, 282–284
pointers, 630, 634–635, 637–639
subtraction, 292–295
Modifiers
class, 407–410
enums, 586
interface, 562
partial types, 422
struct, 538
Modulo operator, 288–290
Most derived method implementation, 467
Most encompassing types, 190
Most specific operators, 189
Move method, 673
Moveable variables
described, 630–631
fixed addresses for, 640–645
MoveNext method, 370, 391, 525–527, 530, 533–535
Multi-dimensional arrays, 9, 44, 553, 557–558
Multi-use attribute classes, 604
Multiple inheritance, 46–47, 569
Multiple statements, 350
Multiplication operator, 12, 285–287
Multiplicative operators, 12
Multiplier class, 50–51
Multiply method, 50
Mutual-exclusion locks, 385–387
N
escape sequence, 70
Named constants. See Enumerations and enum types
Named parameters, 605–606
Names
binding, 428–429
fully qualified, 115–116
interface members, 569–570
nested types, 436
hiding, 109–112
reserved, 440–442
simple
in primary expressions, 239–242
and type names, 245
namespace keyword, 394
compilation units, 393–394
fully qualified names in, 115–116
in ID string format, 666
syntactic grammar, 704–705
type declarations, 403–404
using directives in, 396–402
NaN (Not-a-Number) value
causes, 130
in floating point comparisons, 299
Negation
logical, 281–282
numeric, 281
Nested array initializers, 557–558
Nested blocks, 92
Nested classes, 408
Nested members, 97–98
Nested scopes, 106
accessibility, 436–438
fully qualified names for, 436
in generic classes, 440
member access contained by, 438–440
this access to, 438
Nesting
aliases, 399
with break, 374
comments, 60
object initializers, 262
New line escape sequence, 70
new modifier
class members, 433–434
classes, 408
delegates, 592
interfaces, 562
new operator
anonymous objects, 271–273
collection initializers, 264–266
constructors, 36
delegates, 269–271
hidden methods, 112
object initializers, 262–264
objects, 259–260
structs, 42
No fall through rule, 361–363
No side effects convention, 485
Non-nested types, 436
Non-nullable value type, 134
Non-virtual methods, 29
Nonterminal symbols, 55–56
Normal form function members, 233
Normalization Form C, 63
Not-a-Number (NaN) value
causes, 130
in floating point comparisons, 299
Notation, grammar, 55–57
NotSupportedException class, 525
Null coalescing operator, 311–313
Null field for events, 39
Null pointers, 628
Null-termination of strings, 645
Null values
for array elements, 45
in classes vs. structs, 541–542
escape sequence for, 70
garbage collector for, 118
Nullable boolean logical operators, 308–309
conversions
explicit, 183–184
implicit, 176
operators, 305–306
equality operators with, 304
NullReferenceException class
array access, 254
with as operator, 306
delegate creation, 270
delegate invocation, 596
description, 601
foreach statement, 371
throw statement, 378
unboxing conversions, 141
Numeric conversions
explicit, 180–183
implicit, 174–175
Numeric promotions, 211–213
O
Object variables, 10
Objects, 123
creation expressions for
definite assignment rules, 166
new operator, 259–260
initializers, 262–264
as instance types, 135
Obsolete attribute, 620–621
Octal literals, 67
One-dimensional arrays, 44
Open types, 143
Operation class, 30–31
Operator notation, 209
Operators, 10, 36, 40, 74, 206
arithmetic. See Arithmetic operators
compound, 342–343
event, 344
simple, 340–342
binary. See Binary operators
conditional, 313–314
declaration, 503–505
enums, 590
in ID string format, 671
invocation, 221
lexical grammar, 685
lifted, 213–214
logical, 307–311
null coalescing, 311–313
numeric promotions, 211–213
operator !=, 40
operator ==, 40
overloading, 208–211
precedence and associativity, 206–208
relational. See Relational operators
shift, 295–296
type-testing, 304–305
unary. See Unary operators
Optional parameters, 517
Optional symbols in grammar notation, 56
OR operators, 12
Order
declaration, 91
execution, 121
Out property, 486
Outer variables, 320–324
OutOfMemoryException class, 267, 270, 292, 601
Output parameters, 25–26, 152–153, 461–462
Output types in type inference, 227
Overflow checking context, 276–279, 385
OverflowException class
addition, 291
checked operator, 277–278
decimal type, 132
description, 602
division, 287–288
increment and decrement operators, 283
Overload resolution, 147
anonymous functions, 319–320
function members, 231–235
Overloaded operators, 10
purpose, 206
shift, 295
Overloading
indexers, 38
methods, 32–34
operators, 208–211
Overridden base methods, 469
Override events, 497–498
Override indexers, 499
Override methods, 469–471
Overriding
event declarations, 498
methods, 29
property declarations, 489–490
P
Padding for pointers, 640
Pair class, 21
Pair-wise declarations, 506–507
<para> tag, 660
Paragraph-separator characters, 59
anonymous functions, 315
arrays, 462–465
attributes, 605–607
entry points, 87
instance constructors, 513, 517
methods, 24–27
declaration, 458–459
types, 459–465
optional, 517
type. See Type parameters
<paramref> tag, 661
params modifier, 26–27, 462–465
Parentheses ()
anonymous functions, 315
in grammar notation, 56
in ID string format, 667
for operator precedence, 208
Parenthesized expressions, 242
Partial methods, 475
partial modifier, 410–411
interfaces, 562
structs, 538
types, 420
Partial types, 410–411, 420–421
attributes, 421
base classes, 423
base interfaces, 423
members, 424
methods, 424–428
modifiers, 422
name binding, 428–429
type parameters and constraints, 422–423
Patterns, query expression, 337–338
Percent signs (%)
assignment operators, 339
remainder operator, 288–290
Periods (.) for base access, 256
<permission> tag, 661
Permitted user-defined conversions, 189
Phases, type inference, 226–227
Plus (+) operator, 280
Plus signs (+)
addition, 290–292
assignment operators, 339
increment operator, 257–259, 282–284
pointers, 637–639
base class, 21
declaration, 18
properties, 486–487
source code, 672–675
Point struct, 43, 341, 540–542, 545–547
Point3D class, 21
Pointers, 623
arithmetic, 638–639
arrays, 632–633
conversions, 631–632
element access, 635–636
in expressions, 633–640
for fixed variables, 640–645
function, 591
member access, 634–635
operators
address-of, 636–637
comparison, 639
increment and decrement, 637–638
sizeof, 639–640
types, 627–630
variables with, 630–631
Pop method, 4
Positional parameters, 605–606
Postfix increment and decrement operators, 257–259
#pragma directive, 85
#pragma warning directive, 85–86
Precedence of operators, 10, 206–208
Prefix increment and decrement operators, 282–284
Preprocessing directives, 74–76
conditional compilation, 76–77, 79–83
declaration, 78–79
diagnostic, 83
lexical grammar, 686–689
line, 84–85
pragma, 85–86
preprocessing expressions, 77–78
region, 83–84
Preprocessing expressions, 77–78
anonymous method, 280
checked and unchecked operators, 276–279
default value, 279–280
element access, 253–255
invocation, 247–253
literals in, 238
member access, 242–246
new operator in
anonymous objects, 271–273
arrays, 266–269
collection initializers, 264–266
delegates, 269–271
object initializers, 262–264
objects, 259–260
parenthesized, 242
postfix increment and decrement operators, 257–259
simple names in, 239–242
this access in, 256
typeof operator, 274–276
Primary operators, 11
PrintColor method, 48
Private constructors, 516–517
Productions, grammar, 55
Program class, 533–534, 543–544
Program structure, 4–6
Projection initializers, 273
Promotions, numeric, 211–213
Propagation, exception, 379
Properties, 4
access to, 219
accessibility, 487–489
automatically implemented, 486–487
declarations, 478–479
example, 35
indexers, 500
interface, 566
member names reserved for, 441–442
overview, 37–38
static and instance, 479
Property accessors, 38
declarations, 480
overview, 480–486
types of, 486
Protected accessibility, 20
declared, 95
instance members, 100–102
Protected internal accessibility, 20, 95
Punctuators
lexical grammar, 685
list of, 74
PurchaseTransaction class, 81
Push method, 4
Q
Qualifiers, alias, 404–406
Query expressions, 324–325
ambiguities in, 326
patterns, 337–338
translations in, 326–337
Question marks (?)
null coalescing operator, 311–313
R
escape sequence, 70
Reachability
blocks, 349
do statements, 366
for statements, 368
labeled statements, 352–353
overview, 348–349
return statements, 378
throw statements, 379
while statements, 365
Read-only properties, 37, 482–485
Read-write properties, 37, 482–483
Reads, volatile, 450
Real literals, 68–69
ReAlloc method, 650
Recommended tags for comments, 655–665
Rectangle class, 263–264
Rectangle struct, 341–342
ref modifier, 25–26
explicit, 184–185
implicit, 176–178
Reference parameters, 25, 151–152, 460–461
class, 136
delegate, 136
equality operators, 301–303
interface, 137
object, 136
string, 136
References, 123
parameter passing by, 25
variable, 171–172
Referencing static class types, 410
Referent types, pointer, 627
Region directives, 83–84
Regular string literals, 71–72
Reimplementation, interface, 581–583
booleans, 300
decimal numbers, 299–300
delegates, 303–304
enumerations, 300
integers, 298
lifted, 214
reference types, 301–303
strings, 303
Release semantics, 450
Remainder operator, 288–290
<remarks> tag, 662
remove accessors
for attributes, 610
RemoveEventHandler method, 497
Removing delegates, 294
Reserved attributes, 615
AttributeUsage, 615
Conditional, 616–619
Obsolete, 620–621
Reserved names for class members, 440–442
Reset method, 536
Resolution
function members, 231–235
operator overload, 32, 210–211
overload, 147
Resources, using statement for, 387–390
return statement
definite assignment rules, 162
example, 16
methods, 28
overview, 377–378
with yield, 390–392
Return type
entry points, 89
inferred, 228–229
<returns> tag, 662
Right-associative operators, 207
Right shift operator, 296
Rounding, 132
Rules for definite assignment, 157–171
RunMethodImpersonating method, 51–52
running state for enumerator objects, 525–527
Runtime processes
array creation, 267
attribute instance retrieval, 614
delegate creation, 270
function member invocations, 222, 236
increment and decrement operators, 258
object creation, 261
prefix increment and decrement operations, 283–284
unboxing conversions, 141
RuntimeWrappedException class, 381
S
sbyte type, 8
Scopes
aliases, 398–399
attributes, 609
vs. declaration space, 89
local variables, 355–356
for name hiding, 109–112
overview, 106–109
Sealed accessors, 490
Sealed events, 497–498
Sealed indexers, 499
Sealed methods, 472–473
Sections for attributes, 607
<see> tag, 663
<seealso> tag, 663–664
select clauses, 325, 327–328, 334
Selection statements, 358
if, 358–359
switch, 359–364
Semicolons (;)
accessors, 481
interface identifiers, 566
method bodies, 477
namespace declarations, 394
Sequences in query expressions, 325
set accessors, 490
for attributes, 610
defined, 37
working with, 480–483
SetItems method, 46
SetNextSerialNo method, 28–29
SetText method, 46
Shape class, 473
Shift operators
described, 12
overview, 295–296
Short-circuiting logical operators, 309
ShowHelp method, 54
Side effects
with accessors, 485
and execution order, 121
Signatures
anonymous functions, 317–318
indexers, 500
methods, 24
operators
binary, 506
conversion, 509
unary, 505
Signed integrals, 8
Simple assignment
definite assignment rules, 167
overview, 340–342
Simple expression assignment rules, 165
Simple names
in primary expressions, 239–242
and type names, 245
Single-dimensional arrays
defined, 553
example, 44
initializers, 558
Single-line comments, 59–60, 653–654
Single quotes (') for characters, 69–70
Single-use attribute classes, 604
SizeOf method, 651
sizeof operator, 639–640
Slashes (/)
assignment operators, 339
division, 287–288
Slice method, 476
Source files
compilation, 5
described, 55
Point class, 672–675
Source types in conversions, 189
SplitPath method, 462
Square brackets ([])
attributes, 607
indexers, 38
Square method, 50
Squares class, 27
Stack allocation, 648–649
stackalloc operator, 630, 648–649
StackOverflowException class, 602, 649
Standard conversions, 188
Startup, application, 86–87
Statement lists, 350–351
Statements, 347
blocks in, 350–351
checked and unchecked, 385
declaration, 353–356
definite assignment rules, 158
empty, 351–352
end points and reachability, 348–349
in grammar notation, 56
iteration, 364
do, 366
for, 366–368
foreach, 368–372
while, 365
jump, 373–374
break, 374
continue, 375
goto, 375–377
return, 377–378
throw, 378–380
labeled, 352–353
lock, 385–387
overview, 13–18
selection, 358
if, 358–359
switch, 359–364
syntactic grammar, 700–704
try, 380–384
using, 387–390
yield, 390–392
States, definite assignment, 157
Static classes, 409–410
Static constructors, 36
in classes vs. structs, 547
overview, 518–520
Static events, 497
for constants, 448–449
initialization, 451–455
read-only, 448–450
Static members, 434–435
Static methods, 24
garbage collection, 117
static modifier, 409–410
Static properties, 479
Static variables, 150, 447–448
Status codes, termination, 89
Strings
concatenation, 291–292
equality operators, 303
literals, 71–73
null-termination, 645
switch governing type, 363
Structs, 537
assignment, 541
boxing and unboxing, 542–544
vs. classes, 539–547
constructors, 546–547
declarations, 537–538
default values, 541–542
destructors, 547
examples
database boolean type, 549–551
database integer type, 546–548
field initializers in, 545
inheritance, 541
instance variables, 150
interface implementation by, 47
overview, 41–43
syntactic grammar, 714–715
this access in, 545
value semantics, 540–541
Subtraction operator, 292–295
Suffixes, numeric, 66–69
SuppressFinalize method, 89
suspended state, 525–527
Swap method, 25
switch statement
definite assignment rules, 160
example, 15
overview, 359–364
reachability, 349
Syntactic grammar, 57
arrays, 715–716
attributes, 718–720
basic concepts, 689
classes, 706–714
delegates, 718
enums, 717–718
expressions, 691–700
interfaces, 716–717
namespaces, 704–705
statements, 700–704
structs, 714–715
types, 689–691
variables, 691
System-level exceptions, 599
System namespace, 126–127
T
escape sequence, 70
Tab escape sequence, 70
Tags for comments, 655–665
Target types in conversions, 189
Targets
goto, 376
jump, 373
Terminal symbols, 55–56
Termination, application, 88–89
Ternary operators, 206, 313–314
TextReader class, 389
TextWriter class, 389
this access
classes vs. structs, 545
indexers, 38
instance constructors, 517
nested types, 438
overview, 256
properties, 479
static methods, 28
Three-dimensional arrays, 44
Throw points, 379
throw statement
definite assignment rules, 161
example, 17
for exceptions, 599
overview, 378–380
Tildes (~)
bitwise complement, 282
conversion, 671
ToInt32 method, 476
Tokens, 61
identifiers, 62–64
keywords, 65
lexical grammar, 681
literals, 65–74
operators, 74
unicode character escape sequence, 61–62
ToString method, 292
and boxing, 543–544
DBBool, 551
DBInt, 548
Point, 673–674
Translate method, 673
Translations in query expressions, 326–337
Transparent identifiers in query expressions, 327, 335–337
Tree class, 533–534
Tree types, expression, 146–148
Trig class, 516–517
True value, 66
try statement
definite assignment rules, 162–165
example, 17
for exceptions, 600
with goto, 376–377
overview, 380–384
Two-dimensional arrays
allocating, 44
initializers, 558
Type casts, 49
Type inference, 224–231
Type names, 112–115
fully qualified, 115–116
identical, 245
Type parameters, 20–21, 145–146
class declarations, 411
constraints, 414–420
conversions, 186–187
implicit conversions, 179
partial types, 422–423
Type-safe design, 1
Type testing operators
as, 305–306
described, 12
is, 304–305
TypeInitializationException class, 600, 602
typeof operator
pointers with, 627
primary expressions, 274–276
<typeparam> tag, 665
<typeparamref> tag, 665
Types, 123
aliases for, 395–400
attribute parameter, 606–607
boxing and unboxing, 138–140
in ID string format, 666–668
importing, 400–402
instance, 431
nullable. See Nullable types
overview, 6–10
partial. See Partial types
pointer. See Pointers
reference. See Reference types
syntactic grammar, 689–691
value. See Value types
U
uint type, 8
ulong type, 8
Unary operators, 280
cast expressions, 284–285
in ID string format, 671
lifted, 213–214
minus, 281
numeric promotions, 212
overload resolution, 210
overloadable, 208–209
overview, 505–506
plus, 280
prefix increment and decrement, 282–284
Unassigned variables, 157
Unboxing conversions
described, 185
overview, 140–141
Unboxing operations
in classes vs. structs, 542–544
example, 9
unchecked statement
definite assignment rules, 158
example, 17
overview, 385
in primary expressions, 276–279
#undef directive, 76–79
Undefined conditional compilation symbols, 76
Underlying types
nullable, 134
Underscore characters (_) for identifiers, 62–64
Unicode characters
escape sequence, 61–62
for strings, 7
Unicode Normalization Form C, 63
Unified type system, 1
Uniqueness
aliases, 405–406
interface implementations, 574–575
Unmanaged types, 627
Unreachable statements, 348
Unsafe code, 623
contexts in, 624–627
dynamic memory allocation, 649–651
fixed-size buffers, 645–648
fixed statement, 640–645
grammar extensions for, 720–723
pointers
arrays, 632–633
conversions, 631–632
in expressions, 633–640
types, 627–630
stack allocation, 648–649
unsafe modifier, 624–627
Unsigned integrals, 7
Unwrapping non-nullable value types, 134
User-defined conversions, 188
evaluation, 189–191
lifted operators, 189
overview, 507–510
permitted, 189
User-defined operators
candidate, 211
conditional logical, 310–311
ushort type, 8
for aliases, 397–400
definite assignment rules, 164–165
example, 18
for importing types, 400–402
purpose, 3
V
v escape sequence, 70
Value method, 547
Value parameters, 25, 151, 459–460
Value property, 134
<value> tag, 664
Value types, 124–125
bool, 133
constraints, 415–416
contents, 10
decimal, 131–133
default constructors, 125–126
described, 7
enumeration, 133
floating point, 130–131
integral, 128–130
nullable, 134
simple, 126–128
struct, 126
Values
array types, 554
classes vs. structs, 540–541
default, 125
classes vs. structs, 541–542
initialization, 154–155
enums, 590
expressions, 205
fields, 447–448
local constants, 357
variables, 149, 154–155, 354–355
VariableReference class, 30–31
Variables, 149
anonymous functions, 320–324
array elements, 151
default values, 154–155
definite assignment. See Definite assignment
fixed addresses for, 640–645
fixed and moveable, 630–631
local, 153–154
in methods, 27–28
output parameters, 152–153
overview, 10
query expressions, 325, 327–329
reference parameters, 151–152
references, 171–172
syntactic grammar, 691
value parameters, 151
Verbatim identifiers, 64
Verbatim string literals, 71–72
Versioning
of constants, 449
described, 1
Vertical bars (|)
assignment operators, 339
definite assignment rules, 168–169
logical operators, 307–311
preprocessing expressions, 77
Vertical tab escape sequence, 70
Viewers, documentation, 653
Virtual events, 497–498
Virtual indexers, 499
Virtual methods
overview, 29–32
working with, 466–469
Visibility in scope, 109
void type and values
entry point method, 88
events, 496
pointers, 628
with typeof, 275
Volatile fields, 450–451
W
WaitForPendingFinalizers method, 120
#warning directive, 83
warnings, preprocessing directives, 85–86
where clauses
query expressions, 329–334
type parameter constraints, 144, 415
while statement
definite assignment rules, 160
example, 15
overview, 365
Whitespace
in comments, 654
defined, 60–61
in ID string format, 666
lexical grammar, 681
Win32 component interoperability, 621
Wrapping non-nullable value types, 134
Write method, 26
Write-only properties, 37, 482–483
Writes, volatile, 450
X
XAttribute class, 611–612
XML (Extensible Markup Language), 653–654, 674–677
XOR operators, 12
Y
yield statement
definite assignment rules, 165
example, 16
overview, 390–392
yield break, 526–527
yield return, 526–527
Yield type iterators, 524