RB Whitaker - The C# Player’s Guide Second Edition [2015, PDF, ENG]

1. The C# Programming Language 3
What Exactly is C#? 3
What is the .NET Framework? 4
C# and .NET Versions 5
2. Installing Visual Studio 6
Versions of Visual Studio 7
The Installation Process 8
Alternatives to Visual Studio 8
3. Hello World: Your First C# Program 10
Creating a New Project 11
A Brief Tour of Visual Studio 12
Building Blocks: Projects, Solutions, and Assemblies 13
Modifying Your Project 13
Compiling and Running Your Project 15
A Closer Look at Your Program 16
Whitespace Doesn’t Matter 18
vi Table of Contents
Semicolons 19
4. Comments 20
What is a Comment? 20
Why Should I Use Comments? 20
How to Make Comments in C# 21
How to Make Good Comments 22
Part 2: The Basics
5. Variables 25
What is a Variable? 25
Creating Variables 26
Assigning Values to Variables 27
Retrieving the Contents of a Variable 28
How Data is Stored 29
Good Variable Names 30
6. The C# Type System 32
An Introduction to the Type System 32
The int Type 32
The byte, short, and long Types 33
The sbyte, ushort, uint, and ulong Types 33
The char Type 34
The float, double, and decimal Types 35
The bool Type 37
The string Type 38
7. Basic Math 40
Operations and Operators 41
Addition, Subtraction, Multiplication, and Division 41
The Remainder Operator 43
Unary “+” and “-” Operators 44
Order of Operations and Parentheses 44
Why the ‘=‘ Sign Doesn’t Mean Equals 45
Compound Assignment Operators 45
8. User Input 47
User Input from the Console 47
Converting Types 47
A Complete Sample Program 48
Escape Characters 50
String Interpolation 51
9. More Math 53
Integer Division 54
Working with Different Types and Casting 55
Division by Zero 56
Infinity, NaN, e, π, MinValue, and MaxValue 57
vii
Overflow and Underflow 58
Incrementing and Decrementing 58
10. Decision Making 60
The ‘if’ Statement 61
The ‘else’ Statement 62
‘else if’ Statements 62
Curly Braces Not Always Needed 63
Relational Operators: ==, !=, <, >, <=, >= 64
Using ‘bool’ in Decision Making 65
The ! Operator 66
Conditional Operators: && and || (And and Or) 67
Nesting If Statements 67
The Conditional Operator ?: 68
11. Switch Statements 69
The Basics of Switch Statements 70
Types Allowed with Switch Statements 71
No Implicit Fall-Through 71
12. Looping 73
The While Loop 73
The Do-While Loop 75
The For Loop 75
Breaking Out of Loops 76
Continuing to the Next Iteration of the Loop 77
Nesting Loops 77
Still to Come: Foreach 79
13. Arrays 80
What is an Array? 80
Creating Arrays 81
Getting and Setting Values in Arrays 81
More Ways to Create Arrays 82
Array Length 82
Some Examples with Arrays 83
Arrays of Arrays and Multi-Dimensional Arrays 83
The ‘foreach’ Loop 85
14. Enumerations 86
The Basics of Enumerations 86
Why Enumerations are Useful 88
Underlying Types 88
Assigning Numbers to Enumeration Values 89
15. Methods 90
Creating a Method 91
Calling a Method 93
viii Table of Contents
Returning Stuff from a Method 94
Sending Stuff to a Method 96
Passing in Multiple Parameters 96
Method Overloading 97
Revisiting the Convert and Console Classes 99
XML Documentation Comments 99
The Minimum You Need to Know About Recursion 100
16. Value and Reference Types 102
The Stack and the Heap 102
Memory Management and Garbage Collection 103
References 104
Value Types and Reference Types 104
Null: References to Nothing 106
Value and Reference Semantics 107
Part 3: Object-Oriented Programming
17. Classes and Objects 113
Modeling the Real World 113
Working with an Existing Class 114
Using an Object 115
The Power of Objects 116
Classes are Reference Types 116
18. Making Your Own Classes 118
Creating a New Class 119
Adding Instance Variables 120
Access Modifiers: private and public 121
Adding Constructors 121
Adding Methods 125
The ‘static’ Keyword 127
The ‘internal’ Access Modifier 129
Finishing the Sample 130
19. Properties 132
The Motivation for Properties 133
Creating Properties 133
Different Accessibility Levels 135
Auto-Implemented Properties 136
Object Initializer Syntax 137
20. Structs 138
Creating a Struct 138
Structs vs. Classes 139
Deciding Between a Struct and a Class 141
Prefer Immutable Value Types 141
The Built-In Types are Aliases 141
ix
21. Inheritance 144
Base Classes 145
Derived Classes 145
Using Derived Classes 146
Constructors and Inheritance 148
The ‘protected’ Access Modifier 148
The Base Class of Everything: object 148
Sealed Classes 149
Partial Classes 149
C# Does Not Support Multiple Inheritance 150
22. Polymorphism, Virtual Methods, and Abstract Classes 151
Polymorphism 152
Revisiting the ‘base’ Keyword 153
Abstract Base Classes 154
The ‘new’ Keyword with Methods 155
23. Interfaces 156
What is an Interface? 156
Creating an Interface 157
Using Interfaces 158
Multiple Interfaces and Inheritance 159
24. Using Generics 161
The Motivation for Generics 161
What are Generics? 163
The List Class 164
The IEnumerable<T> Interface 165
The Dictionary Class 166
25. Making Generic Types 167
Creating Your Own Generic Types 168
Using Your Generic Type in Your Class 168
Constraints for Type Parameters 170
Generic Methods 172
Part 4: Advanced Topics
26. Namespaces and Using Directives 175
Namespaces 175
Fully Qualified Names 176
Using Directives 176
The Error ‘The type or namespace X could not be found’ 177
Name Collisions 178
Static Using Directives 179
27. Methods Revisited 181
Optional Parameters 181
x Table of Contents
Named Parameters 182
Variable Number of Parameters 183
The ‘out’ and ‘ref’ Keywords 183
28. Reading and Writing Files 186
All At Once 186
Text-Based Files 188
Binary Files 189
29. Error Handling and Exceptions 191
How Exception Handling Works 192
Catching Exceptions 193
Not Giving the Exception Variable a Name 194
Handling Different Exceptions in Different Ways 194
Throwing Exceptions 195
The ‘finally’ Keyword 196
Exception Filters 197
Some Rules about Throwing Exceptions 198
30. Delegates 199
Delegates: Treating Methods like Objects 199
Creating a Delegate 199
Using Delegates 200
The Delegate and MulticastDelegate Classes 201
Delegate Chaining 203
The Action and Func Delegates 205
31. Events 206
Defining an Event 207
Raising an Event 208
Attaching and Detaching Event Handlers 210
Common Delegate Types Used with Events 211
The Relationship between Delegates and Events 212
32. Operator Overloading 214
Overloading Operators 215
33. Indexers 219
How to Make an Indexer 219
Using Other Types as an Index 220
Index Initializer Syntax 221
34. Extension Methods 223
Creating an Extension Method 224
35. Lambda Expressions 227
The Motivation for Lambda Expressions 227
Lambda Expressions 229
Multiple and Zero Parameters 230
Type Inference and Explicit Types 230
Statement Lambdas 231
xi
Scope in Lambda Expressions 231
Expression-Bodied Members 231
36. Query Expressions 233
What is a Query Expression? 233
LINQ and Query Expressions 234
Creating a Simple Query Expression 234
More Complicated where Clauses 235
Multiple from Clauses 236
Ordering Results 237
Retrieving a Different Type of Data 237
Method Call Syntax 237
We’re Just Scratching the Surface 238
37. Threads 239
Threading Code Basics 240
Using ParameterizedThreadStart 242
Thread Safety 244
38. Asynchronous Programming 246
What is Asynchronous Programming? 247
Approaches from the Early Days 247
The Task-based Asynchronous Pattern 251
The ‘async’ and ‘await’ Keywords 252
39. Other Features in C# 254
Iterators and the Yield Keyword 255
Constants 256
Unsafe Code 257
Attributes 259
The ‘nameof’ Operator 260
Bit Fields 261
Reflection 264
Using Statements and the IDisposable Interface 265
Preprocessor Directives 266
Implicitly Typed Local Variables and Anonymous Types 268
Nullable Types 269
Simple Null Checks: Null Propagation Operators 270
Command Line Arguments 272
User-Defined Conversions 273
Part 5: Mastering the Tools
40. C# and the .NET Framework 277
Binary, Assembly, Languages, and Compiling 277
Virtual Machines and the CLR 278
Advantages of the CLR 281
xii Table of Contents
The Drawbacks of Virtual Machines 282
The BCL and FCL Class Libraries 283
41. Getting the Most from Visual Studio 285
Windows 285
The Options Dialog 287
Including and Excluding Files 288
Showing Line Numbers 288
IntelliSense 289
Basic Refactoring 290
Keyboard Shortcuts 290
42. Referencing Other Projects 291
Referencing Existing Projects 292
Adding a Reference to .NET Framework Assemblies 293
Adding a DLL 294
43. Handling Common Compiler Errors 296
Understanding Compiler Errors 296
Compiler Warnings 297
Common Compiler Errors 297
General Tips for Handling Errors 302
44. Debugging Your Code 304
Launching Your Program in Debug Mode 304
Viewing Exceptions 305
Editing Your Code While Debugging 306
Breakpoints 307
Stepping Through Your Program 308
45. How Your Project Files are Organized 311
Visual Studio’s Projects Directory 312
The Solution Directory 312
The Project Directory 313
Part 6: Wrapping Up
46. Try It Out! 317
Message from Julius Caesar 318
Reverse It! 319
Pig Dice 319
Connect Four 320
Conway’s Game of Life 320
47. What’s Next? 323
Other Frameworks and Libraries 323
Other Topics 325
Make Some Programs 325
Where Do I Go to Get Help? 326
Parting Words 326