C# 10.0 All-in-One For Dummies

Name: C# 10.0 All-in-One For Dummies
Brand: Wiley
Price: 32.99 EUR
Availability: OnlineOnly

John Paul Mueller(Autor*in)

Wiley (Verlag)

1. Auflage

Erschienen am 5. Januar 2022

864 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-1-119-84012-1 (ISBN)

32,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Person

Inhalt

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 TrackDownAMate.com 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

Relying on the Create() method 284

Creating tuples with more than two items 284

Chapter 3: Let Me Say This about this 287

Passing an Object to a Method 288

Comparing Static and Instance Methods 290

Employing static properties and methods effectively 291

Employing instance properties and methods effectively 293

Expanding a method's full name 295

Accessing the Current Object 296

What is the this keyword? 298

When is the this keyword explicit? 299

Using Local Functions 300

Creating a basic local function 300

Using attributes with local functions 301

Chapter 4: Holding a Class Responsible 303

Restricting Access to Class Members 303

A public example of public BankAccount 304

Jumping ahead - other levels of security 306

Why You Should Worry about Access Control 307

Accessor methods 308

Working with init-only setters 309

Access control to the rescue - an example 311

Defining Class Properties 313

Static properties 315

Properties with side effects 315

Accessors with access levels 316

Using Target Typing for Your Convenience 316

Dealing with Covariant Return Types 319

Getting Your Objects Off to a Good Start - Constructors 320

The C#-Provided Constructor 321

Replacing the Default Constructor 322

Constructing something 324

Initializing an object directly with an initializer 326

Seeing that construction stuff with initializers 326

Initializing an object without a constructor 327

Using Expression-Bodied Members 329

Creating expression-bodied methods 329

Defining expression-bodied properties 329

Defining expression-bodied constructors and destructors 330

Defining expression-bodied property accessors 330

Defining expression-bodied event accessors 331

Chapter 5: Inheritance: Is That All I Get? 333

Why You Need Inheritance 334

Inheriting from a BankAccount Class (a More Complex Example) 335

Working with the basic update 336

Tracking the BankAccount and SavingsAccount classes features 339

IS_A versus HAS_A - I'm So Confused_A 342

The IS_A relationship 342

Gaining access to BankAccount by using containment 343

The HAS_A relationship 345

When to IS_A and When to HAS_A 346

Other Features That Support Inheritance 346

Substitutable classes 346

Invalid casts at runtime 347

Avoiding invalid conversions with the is operator 348

Avoiding invalid conversions with the as operator 349

Chapter 6: Poly-what-ism? 353

Overloading an Inherited Method 354

It's a simple case of method overloading 354

Different class, different method 355

Peek-a-boo - hiding a base class method 355

Polymorphism 361

Using the declared type every time (Is that so wrong?) 362

Using is to access a hidden method polymorphically 364

Declaring a method virtual and overriding it 365

Getting the most benefit from polymorphism 368

C# During Its Abstract Period 368

Class factoring 369

The abstract class: Left with nothing but a concept 373

How do you use an abstract class? 374

Creating an abstract object - not! 377

Sealing a Class 377

Chapter 7: Interfacing with the Interface 379

Introducing CAN_BE_USED_AS 379

Knowing What an Interface Is 381

How to implement an interface 382

Using the newer C# 8.0 additions 383

How to name your interface 386

Why C# includes interfaces 386

Mixing inheritance and interface implementation 387

And he-e-e-re's the payoff 387

Using an Interface 388

As a method return type 389

As the base type of an array or collection 389

As a more general type of object reference 390

Using the C# Predefined Interface Types 390

Looking at a Program That CAN_BE_USED_AS an Example 391

Creating your own interface at home in your spare time 391

Implementing the incomparable I Comparable interface 392

Creating a list of students 394

Testing everything using Main() 395

Unifying Class Hierarchies 396

Hiding Behind an Interface 399

Inheriting an Interface 401

Using Interfaces to Manage Change in Object-Oriented Programs 402

Making flexible dependencies through interfaces 403

Abstract or concrete: When to use an abstract class and when to use an interface 404

Doing HAS_A with interfaces 405

Chapter 8: Delegating Those Important Events 407

E.T., Phone Home - The Callback Problem 408

Defining a Delegate 408

Pass Me the Code, Please - Examples 411

Delegating the task 411

First, a simple example 412

Considering the Action, Func, and Predicate delegate types 413

A More Real-World Example 415

Putting the app together 416

Setting the properties and adding event handlers 418

Looking at the workhorse code 419

Shh! Keep It Quiet - Anonymous Methods 421

Defining the basic anonymous method 421

Using static anonymous methods 422

Working with lambda discard parameters 424

Stuff Happens - C# Events 424

The Observer design pattern 425

What's an event? Publish/Subscribe 425

How a publisher advertises its events 426

How subscribers subscribe to an event 427

How to publish an event 427

How to pass extra information to an event handler 428

A recommended way to raise your events 429

How observers "handle" an event 430

Chapter 9: Can I Use Your Namespace in the Library? 433

Dividing a Single Program into Multiple Source Files 434

Working with Global using Statements 435

Dividing a Single Program into Multiple Assemblies 437

Executable or library? 437

Assemblies 437

Executables 438

Class libraries 439

Putting Your Classes into Class Libraries 439

Creating the projects for a class library 439

Creating a stand-alone class library 440

Adding a second project to an existing solution 442

Creating the code for the library 445

Using a test application to test a library 446

Going Beyond Public and Private: More Access Keywords 448

Internal: For CIA eyes only 448

Protected: Sharing with subclasses 451

Putting Classes into Namespaces 453

Declaring a namespace 454

Using file-scoped namespaces 456

Relating namespaces to the access keyword story 456

Using fully qualified names 458

Working with partial classes 459

Working with Partial Methods 463

Defining what partial methods do 463

Creating a partial method 464

Chapter 10: Improving Productivity with Named and Optional Parameters 465

Exploring Optional Parameters 466

Working with optional value parameters 466

Avoiding optional reference types 468

Looking at Named Parameters 470

Using Alternative Methods to Return Values 470

Output (out) parameters 471

Working with out variables 471

Returning values by reference 472

Dealing with null Parameters 473

Chapter 11: Interacting with Structures 475

Comparing Structures to Classes 476

Considering struct limits 476

Understanding the value type difference 477

Determining when to use struct versus class 477

Creating Structures 478

Defining a basic struct 478

Including common struct elements 479

Using supplemental struct elements 482

Working with Read-only Structures 485

Working with Reference Structures 487

Using Structures as Records 489

Managing a single record 489

Adding structures to arrays 489

Overriding methods 490

Using the New Record Type 491

Comparing records to structures and classes 491

Working with a record 492

Using the positional syntax for property definition 493

Understanding value equality 494

Creating safe changes: Nondestructive mutation 494

Using the field keyword 495

Book 3: Designing For C# 497

Chapter 1: Writing Secure Code 499

Designing Secure Software 500

Determining what to protect 500

Documenting the components of the program 501

Decomposing components into functions 502

Identifying potential threats in functions 502

Building Secure Windows Applications 503

Authentication using Windows logon 503

Encrypting information 507

Deployment security 507

Using System.Security 508

Chapter 2: Accessing Data 509

Getting to Know System.Data 510

How the Data Classes Fit into the Framework 512

Getting to Your Data 512

Using the System.Data Namespace 513

Setting up a sample database schema 513

Creating the data access project 514

Connecting to a data source 514

Working with the visual tools 519

Writing data code 521

Chapter 3: Fishing the File Stream 525

Going Where the Fish Are: The File Stream 525

Streams 526

Readers and writers 527

StreamWriting for Old Walter 528

Using the stream: An example 529

Using some better fishing gear: The using statement 534

Pulling Them Out of the Stream: Using StreamReader 537

Systemvoraussetzungen

Als PDF speichern Als Link merken