John Paul Mueller is an author and technical editor with experience in application development, database management, machine learning, and deep learning. He has written hundreds of books and articles helping everyday people learn everything from networking to database management.

Introduction 1

About This Book 1

Foolish Assumptions 2

Icons Used in This Book 3

Beyond the Book 3

Where to Go from Here 4

Book 1: The Basics of C# Programming 5

Chapter 1: Creating Your First C# Console Application 7

Getting a Handle on Computer Languages, C#, and NET 8

What's a program? 8

What's C#? 9

What's NET? 9

What is Visual Studio 2022? 10

Creating Your First Console Application 11

Creating the source program 11

Taking it out for a test drive 17

Making Your Console App Do Something 17

Reviewing Your Console Application 18

The program framework 19

Comments 19

The meat of the program 19

Replacing All that Ceremonial Code: Top-Level Statements 20

Introducing the Toolbox Trick 21

Saving code in the Toolbox 22

Reusing code from the Toolbox 22

Interacting with C# Online 23

Working with Jupyter Notebook: The Short Version 23

Chapter 2: Living with Variability - Declaring Value-Type Variables 25

Declaring a Variable 26

What's an int? 27

Rules for declaring variables 28

Variations on a theme: Different types of int 28

Representing Fractions 30

Handling Floating-Point Variables 31

Declaring a floating-point variable 31

Examining some limitations of floating-point variables 32

Using the Decimal Type: Is It an Integer or a Float? 34

Declaring a decimal 35

Comparing decimals, integers, and floating-point types 35

Examining the bool Type: Is It Logical? 36

Checking Out Character Types 36

The char variable type 36

Special chars 37

The string type 37

What's a Value Type? 39

Comparing string and char 40

Calculating Leap Years: DateTime 41

Declaring Numeric Constants 43

Changing Types: The Cast 44

Letting the C# Compiler Infer Data Types 46

Chapter 3: Pulling Strings 49

The Union Is Indivisible, and So Are Strings 50

Performing Common Operations on a String 51

Comparing Strings 52

Equality for all strings: The Compare() method 52

Would you like your compares with or without case? 56

What If I Want to Switch Case? 56

Distinguishing between all-uppercase and all-lowercase strings 56

Converting a string to upper- or lowercase 57

Looping through a String 58

Searching Strings 59

Can I find it? 59

Is my string empty? 60

Using advanced pattern matching 60

Getting Input from Users in Console Applications 61

Trimming excess white space 62

Parsing numeric input 62

Handling a series of numbers 64

Joining an array of strings into one string 66

Controlling Output Manually 67

Using the Trim() and Pad() methods 67

Using the Concatenate() method 69

Go Ahead and Split() that concatenate program 71

Formatting Your Strings Precisely 72

Using the String.Format() method 72

Using the interpolation method 77

StringBuilder: Manipulating Strings More Efficiently 77

Chapter 4: Smooth Operators 81

Performing Arithmetic 81

Simple operators 82

Operating orders 82

The assignment operator 84

The increment operator 84

Performing Logical Comparisons - Is That Logical? 85

Comparing floating-point numbers: Is your float bigger than mine? 86

Compounding the confusion with compound logical operations 87

Matching Expression Types at [...] 89

Calculating the type of an operation 89

Assigning types 91

Changing how an operator works: Operator overloading 92

Chapter 5: Getting into the Program Flow 95

Branching Out with if and switch 96

Introducing the if statement 97

Examining the else statement 100

Avoiding even the else 101

Nesting if statements 102

Running the switchboard 104

Here We Go Loop-the-Loop 110

Looping for a while 111

Doing the do while loop 114

Breaking up is easy to do 115

Looping until you get it right 116

Focusing on scope rules 120

Looping a Specified Number of Times with for 120

A for loop example 121

Why do you need another loop? 122

Nesting loops 123

Chapter 6: Lining Up Your Ducks with Collections 125

The C# Array 126

The argument for the array 126

The fixed-value array 127

The variable-length array 129

Initializing an array 132

Processing Arrays by Using foreach 133

Working with foreach loops in a standard way 133

Relying on GetEnumerator support 134

Sorting Arrays of Data 136

Using var for Arrays 139

Loosening Up with C# Collections 140

Understanding Collection Syntax 141

Figuring out 142

Going generic 142

Using Lists 143

Instantiating an empty list 143

Creating a list of type int 144

Converting between lists and arrays 144

Searching lists 144

Performing other list tasks 145

Using Dictionaries 145

Creating a dictionary 145

Searching a dictionary 146

Iterating a dictionary 146

Array and Collection Initializers 147

Initializing arrays 148

Initializing collections 148

Using Sets 149

Performing special set tasks 149

Creating a set 150

Adding items to a set 150

Performing a union 151

Performing an intersection 152

Performing a difference 153

Chapter 7: Stepping through Collections 155

Iterating through a Directory of Files 156

Using the LoopThroughFiles program 156

Getting started 157

Obtaining the initial input 157

Creating a list of files 159

Formatting the output lines 160

Displaying the hexadecimal output 161

Running from inside Visual Studio 163

Iterating foreach Collections: Iterators 164

Accessing a collection: The general problem 164

Letting C# access data foreach container 167

Accessing Collections the Array Way: Indexers 169

Indexer format 169

An indexer program example 170

Looping Around the Iterator Block 173

Creating the required iterator block framework 174

Iterating days of the month: A first example 176

What a collection is, really 177

Iterator syntax gives up so easily 178

Iterator blocks of all shapes and sizes 180

Chapter 8: Buying Generic 187

Writing a New Prescription: Generics 188

Generics are type-safe 188

Generics are efficient 189

Classy Generics: Writing Your Own 190

Shipping packages at OOPs 190

Queuing at OOPs: PriorityQueue 191

Unwrapping the package 194

Touring Main() 196

Writing generic code the easy way 197

Saving PriorityQueue for last 198

Using a (nongeneric) Simple Factory class 201

Understanding Variance in Generics 205

Contravariance 206

Covariance 208

Chapter 9: Some Exceptional Exceptions 209

Using an Exceptional Error-Reporting Mechanism 210

About try blocks 211

About catch blocks 211

About finally blocks 212

What happens when an exception is thrown 213

Throwing Exceptions Yourself 215

Can I Get an Exceptional Example? 216

Working with Custom Exceptions 220

Planning Your Exception-Handling Strategy 221

Some questions to guide your planning 221

Guidelines for code that handles errors well 222

How to find out which methods throw which exceptions 223

Grabbing Your Last Chance to Catch an Exception 225

Throwing Expressions 226

Chapter 10: Creating Lists of Items with Enumerations 229

Seeing Enumerations in the Real World 230

Working with Enumerations 231

Using the enum keyword 231

Creating enumerations with initializers 233

Specifying an enumeration data type 234

Creating Enumerated Flags 235

Defining Enumerated Switches 237

Working with Enumeration Methods 238

Book 2: Object-Oriented C# Programming 241

Chapter 1: Showing Some Class 243

A Quick Overview of Object-Oriented Programming 244

Considering OOP basics 244

Extending classes to meet other needs 244

Keeping objects safe 245

Working with objects 246

Defining a Class and an Object 246

Defining a class 247

What's the object? 249

Accessing the Members of an Object 250

Working with Object-Based Code 250

Using the traditional approach 250

Using the C# 9.0 approach 252

Discriminating between Objects 253

Can You Give Me References? 254

Classes That Contain Classes Are the Happiest Classes in the World 256

Generating Static in Class Members 257

Defining const and readonly Data Members 259

Chapter 2: We Have Our Methods 261

Defining and Using a Method 262

Method Examples for Your Files 263

Understanding the problem 264

Working with standard coding methods 265

Applying a refactoring approach 268

Working with local functions 271

Having Arguments with Methods 273

Passing an argument to a method 273

Passing multiple arguments to methods 274

Matching argument definitions with usage 276

Overloading a method doesn't mean giving it too much to do 276

Implementing default arguments 278

Using the Call-by-Reference Feature 280

Defining a Method with No Return Value 281

Returning Multiple Values Using Tuples 282

Using a tuple 283