The standard reference to C#, direct from the language's inventor! A must-have for all C# programmers - the complete, authoritative, detailed technical reference to C# 2.0, with annotated tips and code samples
Includes an exclusive look ahead at C# 3.0
Anders Hejlsberg is the father of C#, and is a revered legend in the programming world
Usage of C# is growing at a fast rate
Table of Contents
top
Preface xiii
PART I: C# 1.0 1
Chapter 1: Introduction 3
1.1 Hello World 4
1.2 Program Structure 5
1.3 Types and Variables 7
1.4 Expressions 11
1.5 Statements 14
1.6 Classes and Objects 18
1.7 Structs 34
1.8 Arrays 35
1.9 Interfaces 37
1.10 Enums 39
1.11 Delegates 40
1.12 Attributes 42
Chapter 2: Lexical Structure 45
2.1 Programs 45
2.2 Grammars 45
2.3 Lexical Analysis 47
2.4 Tokens 51
2.5 Preprocessing Directives 61
Chapter 3: Basic Concepts 73
3.1 Application Startup 73
3.2 Application Termination 74
3.3 Declarations 75
3.4 Members 77
3.5 Member Access 79
3.6 Signatures and Overloading 86
3.7 Scopes 87
3.8 Namespace and Type Names 93
3.9 Automatic Memory Management 95
3.10 Execution Order 99
Chapter 4: Types 101
4.1 Value Types 101
4.2 Reference Types 110
4.3 Boxing and Unboxing 112
Chapter 5: Variables 115
5.1 Variable Categories 115
5.2 Default Values 119
5.3 Definite Assignment 119
5.4 Variable References 133
5.5 Atomicity of Variable References 133
Chapter 6: Conversions 135
6.1 Implicit Conversions 135
6.2 Explicit Conversions 138
6.3 Standard Conversions 142
6.4 User-Defined Conversions 143
Chapter 7: Expressions 147
7.1 Expression Classifications 147
7.2 Operators 149
7.3 Member Lookup 156
7.4 Function Members 157
7.5 Primary Expressions 170
7.6 Unary Operators 193
7.7 Arithmetic Operators 198
7.8 Shift Operators 207
7.9 Relational and Type-Testing Operators 209
7.10 Logical Operators 216
7.11 Conditional Logical Operators 218
7.12 Conditional Operator 220
7.13 Assignment Operators 221
7.14 Expression 226
7.15 Constant Expressions 226
7.16 Boolean Expressions 228
Chapter 8: Statements 229
8.1 End Points and Reachability 230
8.2 Blocks 232
8.3 The Empty Statement 233
8.4 Labeled Statements 233
8.5 Declaration Statements 234
8.6 Expression Statements 236
8.7 Selection Statements 237
8.8 Iteration Statements 243
8.9 Jump Statements 248
8.10 The try Statement 255
8.11 The checked and unchecked Statements 258
8.12 The lock Statement 259
8.13 The using Statement 260
Chapter 9: Namespaces 263
9.1 Compilation Units 263
9.2 Namespace Declarations 264
9.3 Using Directives 265
9.4 Namespace Members 271
9.5 Type Declarations 271
Chapter 10: Classes 273
10.1 Class Declarations 273
10.2 Class Members 277
10.3 Constants 287
10.4 Fields 290
10.5 Methods 299
10.6 Properties 317
10.7 Events 327
10.8 Indexers 333
10.9 Operators 338
10.10 Instance Constructors 343
10.11 Static Constructors 349
10.12 Destructors 352
Chapter 11: Structs 355
11.1 Struct Declarations 355
11.2 Struct Members 356
11.3 Class and Struct Differences 357
11.4 Struct Examples 363
Chapter 12: Arrays 367
12.1 Array Types 367
12.2 Array Creation 369
12.3 Array Element Access 369
12.4 Array Members 369
12.5 Array Covariance 369
12.6 Array Initializers 370
Chapter 13: Interfaces 373
13.1 Interface Declarations 373
13.2 Interface Members 375
13.3 Fully Qualified Interface Member Names 380
13.4 Interface Implementations 380
Chapter 14: Enums 393
14.1 Enum Declarations 393
14.2 Enum Modifiers 394
14.3 Enum Members 394
14.4 The System.Enum Type 397
14.5 Enum Values and Operations 397
Chapter 15: Delegates 399
15.1 Delegate Declarations 399
15.2 Delegate Instantiation 402
15.3 Delegate Invocation 403
Chapter 16: Exceptions 407
16.1 Causes of Exceptions 407
16.2 The System.Exception Class 408
16.3 How Exceptions Are Handled 408
16.4 Common Exception Classes 409
Chapter 17: Attributes 411
17.1 Attribute Classes 411
17.2 Attribute Specification 414
17.3 Attribute Instances 420
17.4 Reserved Attributes 422
17.5 Attributes for Interoperation 428
Chapter 18: Unsafe Code 429
18.1 Unsafe Contexts 429
18.2 Pointer Types 433
18.3 Fixed and Moveable Variables 436
18.4 Pointer Conversions 437
18.5 Pointers in Expressions 438
18.6 The fixed Statement 446
18.7 Stack Allocation 450
18.8 Dynamic Memory Allocation 451
PART II: C# 2.0 455Chapter 19: Introduction to C# 2.0 457
19.1 Generics 458
19.2 Anonymous Methods 463
19.3 Iterators 467
19.4 Partial Types 471
19.5 Nullable Types 472
Chapter 20: Generics 477
20.1 Generic Class Declarations 477
20.2 Generic Struct Declarations 488
20.3 Generic Interface Declarations 488
20.4 Generic Delegate Declarations 490
20.5 Constructed Types 491
20.6 Generic Methods 498
20.7 Constraints 506
20.8 Expressions and Statements 517
20.9 Revised Lookup Rules 521
20.10 Right-Shift Grammar Changes 533
Chapter 21: Anonymous Methods 535
21.1 Anonymous Method Expressions 535
21.2 Anonymous Method Signatures 535
21.3 Anonymous Method Conversions 536
21.4 Anonymous Method Blocks 537
21.5 Outer Variables 538
21.6 Anonymous Method Evaluation 541
21.7 Delegate Instance Equality 542
21.8 Definite Assignment 543
21.9 Method Group Conversions 544
21.10 Delegate Creation Expressions 546
21.11 Implementation Example 546
Chapter 22: Iterators 551
22.1 Iterator Blocks 551
22.2 Enumerator Objects 552
22.3 Enumerable Objects 555
22.4 The yield Statement 556
22.5 Implementation Example 558
Chapter 23: Partial Types 567
23.1 Partial Declarations 567
23.2 Name Binding 571
Chapter 24: Nullable Types 573
24.1 Nullable Types 573
24.2 Conversions 574
24.3 Expressions 580
Chapter 25: Other Features 587
25.1 Property Accessor Accessibility 587
25.2 Static Classes 590
25.3 Namespace Alias Qualifiers 592
25.4 Extern Aliases 596
25.5 Pragma Directives 600
25.6 Default Value Expression 601
25.7 Conditional Attribute Classes 602
25.8 Fixed Size Buffers 603
PART III: Appendixes 609Appendix A Documentation Comments 611
A.1 Introduction 611
A.2 Recommended Tags 613
A.3 Processing the Documentation File 623
A.4 An Example 629
Appendix B Grammar 635
B.1 Lexical Grammar 635
B.2 Syntactic Grammar 644
B.3 Grammar Extensions for Unsafe Code 671
Index 675
Preface
top
The C# project started more than seven years ago, in December 1998, with the goal to create a simple, modern, object-oriented, and type-safe programming language for the new and yet to be named .NET platform. Since then, C# has come a long way. The language is now in use by hundreds of thousands of programmers, it has been standardized by both ECMA and ISO/IEC, and the development of a second version of the language with several major new features has been completed.
This book is a complete technical specification of the C# programming language. The book is divided into three parts. Part I, 'C# 1.0,' includes Chapters 1-18 and describes the C# 1.0 language, as delivered in Visual Studio .NET 2002 and 2003. Part II, 'C# 2.0,' includes Chapters 19-25 and describes the new features of C# 2.0, as delivered in Visual Studio 2005, including generics, anonymous methods, iterators, partial types, and nullable types. Part III, 'Appendixes,' describes documentation comments and summarizes the lexical and syntactic grammars of C# 2.0.
Many people have been involved in the creation of the C# language. The language design team for C# 1.0 consisted of Anders Hejlsberg, Scott Wiltamuth, Peter Golde, Peter Sollich, and Eric Gunnerson. For C# 2.0, the language design team consisted of Anders Hejlsberg, Peter Golde, Peter Hallam, Shon Katzenberger, Todd Proebsting, and Anson Horton. Furthermore, the design and implementation of generics in C# and the .NET Common Language Runtime is based on the 'Gyro' prototype built by Don Syme and Andrew Kennedy of Microsoft Research. Finally, this second edition was edited by Mads Torgersen.
It is impossible to acknowledge all the people who have influenced the design of C#, but we are nonetheless grateful to all of them. Nothing good gets designed in a vacuum, and the constant feedback we receive from our large and enthusiastic community of developers is invaluable.
C# has been and continues to be one of the most challenging and exciting projects on which we've worked. We hope you enjoy using C# as much as we enjoyed creating it.
Anders Hejlsberg
Scott Wiltamuth
Seattle, WA
March 2006
About the Authors
top
Anders Hejlsberg is a programming legend. He is the architect of the C# language and a Microsoft Technical Fellow. He joined Microsoft Corporation in 1996, following a thirteen-year career at Borland, where he was the chief architect of Delphi and Turbo Pascal.
Scott Wiltamuth is General Manager for the Visual Studio Language and Data Tools team at Microsoft Corporation. In his thirteen years at Microsoft, he has worked on a wide range of development tools, including OLE Automation, Visual Basic for Applications, VBScript, JScript, Visual J++, and Visual C#.
Before leaving Microsoft Corporation, Peter Golde served as the lead developer of Microsoft's C# compiler. As the primary Microsoft representative on the ECMA committee that standardized C#, he led the implementation of the compiler and worked on the language design.
