Essential C# 4.0. Mark Michaelis. AAddison-Wesley. Upper Saddle River, NJ 9 Boston Indianapolis. Capetown 8 Sydney 8 Tokyo 0 Singapore * Mexico City

Transcription

1 Essential C# 4.0 Mark Michaelis AAddison-Wesley Upper Saddle River, NJ 9 Boston Indianapolis San Francisco New York Toronto 9 Montreal London 8 Munich «Paris Madrid Capetown 8 Sydney 8 Tokyo 0 Singapore * Mexico City

2 Contents Contents ofc#4.0 Topics Figures Tables xxvii xxix Foreword xxxi Preface xxxv Acknowledgments About the Author xlvii li xxv i Introducing C# i Hello, World 2 Compiling and Running the Application 3 C# Syntax Fundamentals 4 Type Definition 7 Main 8 Statements and Statement Delimiters 10 Whitespace 11 Working with Variables 12 Data Types 13 Declaring a Variable 14 Assigning a Variable 14 Using a Variable 16 Console Input and Output 16 Getting Input from the Console 16 Writing Output to the Console 18 Comments 20 Managed Execution and the Common Language Infrastructure 23

3 -) Contents C# and.net Versioning 26 Common Intermediate Language Summary 30 and ILDASM 2 Data Types 31 Fundamental Numeric Types 32 Integer Types 32 Floating-Point Types (float, double) 33 Decimal Type 34 Literal Values 35 More Fundamental Types 40 Boolean Type (boot) 40 Character Type (char) 41 Strings 43 null and void 51 null 51 The void Nontype 52 Categories of Types 55 Value Types 55 Reference Types 56 Nullable Modifier 57 Conversions between Data Types 58 Explicit Cast 58 Implicit Conversion 62 Type Conversion without Casting 62 Arrays 64 Declaring an Array 65 Instantiating and Assigning Arrays 66 Using an Array 70 Strings as Arrays 76 Common Errors 78 Summary 81 3 Operators and Control Flow 83 Operators 84 Plus and Minus Unary Operators (+, -) 84 Arithmetic Binary Operators (+, -, *, /, %) 85 Parenthesis Operator 92 Assignment Operators (+=, -=, *=, /=, %=) 93 Increment and Decrement Operators (++, - Constant Expressions (const) 98 94

4 Contents m xili Introducing if Statement 102 Nested if 103 Flow Control 98 Code Blocks ({}) 105 Scope and Declaration Space 107 Boolean Expressions 109 Relational and Equality Operators 110 Logical Boolean Operators 111 Logical Negation Operator (\) 113 Conditional Operator (?) 223 Null Coalescing Operator (??J 224 Bitwise Operators (<<,>>, \, &, A, ~) 115 Shift Operators (<<,>>,«=,>>=) 116 Bitwise Operators (&,,A) 227 Bitwise Assignment Operators (&=, =, A=) 220 Bitwise Complement Operator (~) 120 Control Flow Statements, Continued 121 The white and do/while Loops 121 The for Loop 124 The foreach Loop 127 The switch Statement 130 Jump Statements 132 The break Statement 132 The continue Statement 135 The goto Statement 137 C# Preprocessor Directives 138 Excluding and Including Code (#if, #eiif, #else, #endif) 240 Defining Preprocessor Symbols (^define, #undef) 141 Emitting Errors and Warnings (tferror, #warning) 141 Turning Off Warning Messages (#pragma) 242 nowarn:<warn List> Option 143 Specifying Line Numbers (#Line) 143 Hintsfor Visual Editors (#region, #endregion) 144 Summary Methods and Parameters 149 Calling Namespace 152 Type Name 154 Scope 155 Method Name 155 a Method 150 Parameters 155

5 xiv Contents Method Return 155 Statement versus Method Call 156 Declaring a Method 157 Parameter Declaration 159 Method Return Declaration 159 The using Directive 161 Aliasing 164 Returns and Parameters on Ma i n () 165 Parameters 168 Value Parameters 168 Reference Parameters (ref) 170 Output Parameters (out) 171 Parameter Arrays (params) 173 Recursion 176 Method Overloading 179 Optional Parameters 182 Basic Error Handling with Exceptions 186 Trapping Errors 187 Reporting Errors Using Summary 199 a throw Statement Classes 201 Declaring and Instantiating a Class 205 Instance Fields 209 Declaring an Instance Field 209 Accessing an Instance Field 210 Instance Methods 211 Using the th i s Keyword 213 Access Modifiers 220 Properties 222 Declaring a Property 223 Automatically Implemented Properties 225 Naming Conventions 227 Using Properties with Validation 228 Read-Only and Write-Only Properties 230 Access Modifiers on Getters and Setters 231 Properties as Virtual Fields 232 Properties and Method Calls Not Alloiued as ref or out Parameter Values 234 Constructors 236 Declaring a Constructor 237 Default Constructors 239 Object Initializers 239

6 Contents xv Overloading Constructors 241 Constructor Chaining: Calling another Constructor Using this 243 Static Members 247 Static Fields 248 Static Methods 251 Static Constructors 253 Static Properties 254 Static Classes 255 Extension Methods 256 Encapsulating const 258 readonly 259 Nested Classes 260 Partial Classes 262 the Data 258 Defining a Partial Class 263 Partial Methods 264 Summary Inheritance 269 Derivation 270 Casting between Base and Derived Types 272 private Access Modifier 275 protected Access Modifier 276 Extension Methods 278 Single Inheritance 278 Sealed Classes 281 Overriding the Base Class 281 virtual Modifier 282 new Modifier 286 sea Led Modifier 291 base Member 291 Constructors 292 Abstract Classes 293 All Classes Derive from System. Object 299 Verifying the Underlying Type with the is Operator 301 Conversion Using the as Operator 302 Summary Interfaces 305 Introducing Interfaces 306 Polymorphism through Interfaces 307 Interface Implementation 312

7 xvi Contents Explicit Member Implementation 314 Implicit Member Implementation 315 Explicit versus Implicit Interface Implementation 316 Converting between the Implementing Class and Its Interfaces 318 Interface Inheritance 318 Multiple Interface Inheritance 321 Extension Methods on Interfaces 322 Implementing Multiple Inheritance via Interfaces 323 Versioning 326 Interfaces Compared with Classes 328 Summary Value Types 331 Structs 332 Initializing structs 336 Using the default Operator 338 Inheritance and Interfaces with Value Types 338 Boxing 339 Enums 346 Type Compatibility between Enums 349 Converting between Enums and Strings 350 Enums as Flags 351 Summary Well-Formed Types 357 Overriding object Members 357 Overriding ToString() 358 Overriding GetHashCode() 358 Overriding Equals () 361 Guidelines for Implementing Equality 369 Operator Overloading 369 Comparison Operators (==,! =, <, >, <=, >=) 370 Binary Operators (+, -, *, /, %,&, \, A, «, > >) 371 Combining Assignment with Binary Operators (+=,-=,*=,/=, %=, &=...) 373 Conditional Logical Operators (&&, ) 373 Unary Operators (+, -,!, ~, ++, - -, true, fa I s e) 373 Conversion Operators 375 Guidelines for Conversion Operators 377 Referencing Changing the Assembly Target 378 Referencing an Assembly 379 Encapsulation of Types 379 Other Assemblies 377

8 Contents mu xvlt Defining Namespaces 382 Namespace Alias Qualifier 384 XML Comments 385 Associating XML Comments with Programming Constructs 386 Generating an XML Documentation File 388 Garbage Weak References 391 Collection 390 Resource Cleanup 393 Finalizers 393 Deterministic Finalization with the using Statement 395 Garbage Collection and Finalization 398 Resource Utilization and Finalization Guidelines 400 Lazy Initialization 400 Summary Exception Handling 405 Multiple Exception Types 405 Catching Exceptions 407 General Catch Block 409 Guidelines for Exception Handling 411 Defining Custom Exceptions 414 Summary Generics 421 C# without Generics 422 Introducing Generic Types 427 Using a Generic Class 427 Defining a Simple Generic Class 429 Benefits of Generics 430 Type Parameter Naming Guidelines 431 Generic Interfaces and Structs 432 Defining Specifying a Default Multiple Type Arity in Abundance 437 Nested Generic Types 438 Constraints 439 a Constructor and a Finalizer 434 Value 435 Parameters 436 Interface Constraints 442 Base Class Constraints 444 structiclass Constraints 445 Multiple Constraints 446 Constructor Constraints 446 Constraint Inheritance 447

9 xviii b Contents Generic Methods 453 Type Inferencing 454 Specifying Constraints 455 Covariance and Contravariance 457 Enabling Covariance with the out Type Parameter Modifier in C# Enabling Contravariance with the in Type Parameter Modifier in C# Supportfor Parameter Covariance and Contravariance in Arrays 462 Generic Internals 463 Instantiating Generics Based on Value Types 464 Instantiating Generics Based on Reference Types 465 Summary Delegates and Lambda Expressions 469 Introducing Delegates 470 Defining the Scenario 470 Delegate Data Types 472 Delegate Internals 473 Defining a Delegate Type 474 Instantiating a Delegate 475 Anonymous Methods 480 System-Defined Delegates: Funco 483 Lambda Expressions 486 Statement Lambdas 486 Expression Lambdas 489 Outer Variables 495 Expression Trees 498 Summary Events 507 Coding the Observer Pattern with Multicast Delegates 508 Defining Subscriber Methods 508 Defining the Publisher 510 Hooking Up the Publisher and Subscribers 511 Invoking a Delegate 512 Check for null 513 Delegate Operators 514 Sequential Invocation 516 Error Handling 519 Method Returns and Pass-by-Reference 522 Events 523 Why Events? 523 Declaring an Event 525 Coding Conventions 526

10 Contents '% xlx Generics and Delegates 528 Customizing the Event Implementation 532 Summary Collection Interfaces with Standard Query Operators 535 Anonymous Types and Implicitly Typed Local Variables 536 Anonymous Types 537 Implicitly Typed Local Variables (var) 538 More about Anonymous Types and Implicit Local Variables 540 Collection Initializers 543 What Makes a Class a Collection: IEnumerable<T> 546 foreach with Arrays 546 foreach with IEnumerabLe<T> 547 Do Not Modify Collections during foreach Iteration 552 Standard Query Operators 552 Filtering with Where() 556 Projecting with Select() 557 Counting Elements with Count() 561 Deferred Execution 562 Sorting with OrderBy() and ThenBy() 566 Performing an Inner Join with Join() 572 Grouping Results with GroupBy () 575 Implementing a One-to-Many Relationship with GroupJoin () 577 Calling SeLecmany () 580 More Standard Query Operators 582 Summary LINQ with Query Expressions 589 Introducing Query Expressions 590 Projection 592 Filtering 598 Sorting 599 The Let Clause 600 Grouping 602 Query Continuation with into 605 Query Expressions as Method Invocations 608 Summary Building Custom Collections 6n More Collection Interfaces 612 IList<T> versus IDictionary<TKey, TVaLue> 614 IComparable<T> 614 ICoLLection<T> 616

11 xx Contents Primary Collection Classes 617 List Collections: List<T> 617 Dictionary Collections: Dictionary<TKey, TVaLue> 622 Sorted Collections: SortedDictionary<TKey, 5ortedList<T> 626 Stack Collections: Stack<T> 628 Queue Collections: Queue<T> 629 Linked Lists: LinkedList<T> 629 Providing an Index Operator 630 Returning Null or an Empty Collection 634 Iterators 634 Defining an Iterator 636 Iterator Syntax 636 Yielding Values from an Iterator 637 Iterators and State 639 More Iterator Examples 641 Placing a yield return within a Loop 643 Canceling Further Iteration: yield break 645 Creating Multiple Iterators in a Single Class 648 yield Statement Characteristics 649 Summary 650 TVaLue> and 17 Reflection, Attributes, and Dynamic Programming 651 Reflection 652 Accessing Metadata Using System. Type 653 Member Invocation 655 Reflection on Generic Types 660 Attributes 663 Custom Attributes 666 Looking for Attributes 667 Initializing an Attribute through a Constructor 668 System.AttributeUsageAttribute 673 Named Parameters 674 Programming with Dynamic Objects 688 Invoking Reflection Using dynamic 689 dynamic Principles and Behaviors 690 Why Dynamic Binding? 694 Static Compilation versus Dynamic Programming 695 Implementing a Custom Dynamic Object 696 Summary 699

12 Contents % xxl 18 Multithreading 701 Running and Controlling a Separate Thread 706 ContinueMith() 711 Unhandled Exception Handling on Task 715 Canceling a Task 718 Long-Running Tasks 722 Disposing a Task 723 Executing Iterations in Parallel 724 Parallel Exception Handling with System.AggregateException 728 Canceling a Parallel Loop 729 Running LINQ Queries in Parallel 734 Canceling a PLINQ Query 736 Multithreading before.net Framework Asynchronous Operations with System. Threading. Thread 738 Thread Management 740 Thread Pooling 742 Unhandled Exceptions on the AppDomain 744 Summary Synchronization and More Multithreading Patterns 749 Synchronization 750 Synchronization Using Monitor 754 Using the Loch Keyword 757 Choosing a Loch Object 758 Why to Avoid Locking on this, typeof(type), and string 759 Declaring Fields as volatile 760 Using the System. Threading. Inter Locked Class 761 Event Notification with Multiple Synchronization Design More Synchronization Types 766 Thread Local Storage 774 Timers 778 Asynchronous Programming Calling the APM 784 Threads 763 Best Practices 764 Calling the APM Using TPL 791 Asynchronous Delegate Passing Data to and from Model 783 Invocation 797 an Alternate Thread 799 Event-Based Asynchronous Pattern (EAP) 801 Background Establishing Exception Handling 808 Worker Pattern 804 the Pattern 807

13 a Contents Windows UI Programming 809 Windows Forms 809 Windows Presentation Foundation (WPF) 811 Summary Platform Interoperability and Unsafe Code 815 Platform Invoke 816 Declaring External Functions 817 Parameter Data Types 818 Using ref Rather Than Pointers 819 Using StructLayoutAttribute for Sequential Layout 820 Error Handling 821 Using SafeHandLe 823 Calling External Functions 826 Simplifying API Calls with Wrappers 828 Function Pointers Map to Delegates 829 Guidelines 829 Pointers and Addresses 830 Unsafe Code 830 Pointer Declaration 832 Assigning a Pointer 834 Dereferencing a Pointer 83 7 Accessing the Member ofa Referent Type 839 Summary The Common Language Infrastructure 843 Defining the Common Language Infrastructure (CLI) CLI Implementations 845 C# Compilation to Machine Code 847 Runtime 849 Garbage Collection 849 Garbage Collection on.net 850 Type Safety 851 Code Access Security 852 Platform Portability 852 Performance 853 Application Domains 854 Assemblies, Manifests, and Modules 855 Common Intermediate Language (CIL) 858 Common Type System (CTS) 858 Common Language Specification (CLS) 859

14 Contents a xxiii Base Class Library (BCL) 860 Metadata 860 Summary 862 A Downloading and Installing the C# Compiler Platform 865 and the CLI B Full Source Code Listings 869 C Concurrent Classes from System.Collections.Concurrent 895 D C# 2.0 Topics 899 E C# 3.0 Topics 903 F C# 4.0 Topics 905 Index 907