Beginning C# 7 Programming with Visual Studio 2017 E-Book

Benjamin Perkins

• Herausgeber: John Wiley & Sons
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Englisch

Seitenzahl: 1255

Veröffentlichungsjahr: 2018

Beschreibung

Easily get started programming using the ultra-versatile C# 7 and Visual Studio 2017 Beginning C# 7 Programming with Visual Studio 2017 is the beginner's ultimate guide to the world's most popular programming language. Whether you're new to programming entirely, or just new to C#, there has never been a better time to get started. The new C# 7 and Visual Studio 2017 updates feature a number of new tools and features that streamline the workflow, simplify the code, and make it easier than ever to build high-quality apps. This book walks you through everything you need to know, starting from the very basics, to have you programming in no time. You'll learn about variables, flow control, and object oriented programming, then move into Web and Windows programming as well as databases and XML. The companion website provides downloadable code examples, and practical Try It Out sections provide explicit, step-by-step instructions for writing your own useful, customizable code. C# 7 can be used to build Windows applications, program Windows 10, and write Web apps when used alongside ASP.NET. With programming skills becoming de rigueur in fields far beyond the tech world, C# 7 is a great place to start building versatile, helpful skills. This book gets you started quickly and easily with instruction from a master-team of C# programmers. * Learn how to program using the world's leading programming language * Build smarter, faster apps using the latest features in C# 7 and Visual Studio 2017 * Find and fix bugs sooner, saving headaches down the line * Integrate with all .NET Core, Azure applications, cloud services, Docker containers, and more The world of programming can seem intimidating to a beginner, and the prospect of learning a whole new "language" can seem daunting. Beginning C# 7 Programming with Visual Studio 2017 demystifies the process and shows you how to bring your ideas to life.

Leseprobe

Table of Contents

Cover

Title Page

Introduction

PART I: The C# Language

1 Introducing C#

WHAT IS THE .NET FRAMEWORK?

WHAT IS C#?

VISUAL STUDIO 2017

2 Writing a C# Program

THE VISUAL STUDIO 2017 DEVELOPMENT ENVIRONMENT

CONSOLE APPLICATIONS

DESKTOP APPLICATIONS

3 Variables and Expressions

BASIC C# SYNTAX

BASIC C# CONSOLE APPLICATION STRUCTURE

VARIABLES

EXPRESSIONS

4 Flow Control

BOOLEAN LOGIC

BRANCHING

LOOPING

5 More about Variables

TYPE CONVERSION

COMPLEX VARIABLE TYPES

STRING MANIPULATION

6 Functions

DEFINING AND USING FUNCTIONS

VARIABLE SCOPE

THE MAIN() FUNCTION

STRUCT FUNCTIONS

OVERLOADING FUNCTIONS

USING DELEGATES

7 Debugging and Error Handling

DEBUGGING IN VISUAL STUDIO

ERROR HANDLING

8 Introduction to Object‐Oriented Programming

WHAT IS OBJECT‐ORIENTED PROGRAMMING?

OOP TECHNIQUES

OOP IN DESKTOP APPLICATIONS

9 Defining Classes

CLASS DEFINITIONS IN C#

SYSTEM.OBJECT

CONSTRUCTORS AND DESTRUCTORS

OOP TOOLS IN VISUAL STUDIO

CLASS LIBRARY PROJECTS

INTERFACES VERSUS ABSTRACT CLASSES

STRUCT TYPES

SHALLOW COPYING VERSUS DEEP COPYING

10 Defining Class Members

MEMBER DEFINITIONS

ADDITIONAL CLASS MEMBER TOPICS

INTERFACE IMPLEMENTATION

PARTIAL CLASS DEFINITIONS

PARTIAL METHOD DEFINITIONS

EXAMPLE APPLICATION

THE CALL HIERARCHY WINDOW

11 Collections, Comparisons, and Conversions

COLLECTIONS

COMPARISONS

CONVERSIONS

12 Generics

WHAT ARE GENERICS?

USING GENERICS

DEFINING GENERIC TYPES

VARIANCE

13 Additional C# Techniques

THE :: OPERATOR AND THE GLOBAL NAMESPACE QUALIFIER

CUSTOM EXCEPTIONS

EVENTS

EXPANDING AND USING CARDLIB

ATTRIBUTES

INITIALIZERS

TYPE INFERENCE

ANONYMOUS TYPES

DYNAMIC LOOKUP

ADVANCED METHOD PARAMETERS

LAMBDA EXPRESSIONS

PART II: Windows Programming

14 Basic Desktop Programming

XAML

THE PLAYGROUND

CONTROL LAYOUT

THE GAME CLIENT

15 Advanced Desktop Programming

CREATING AND STYLING CONTROLS

WPF USER CONTROLS

THE MAIN WINDOW

PUTTING IT ALL TOGETHER

PART III: Cloud and Cross‐Platform Programming

16 Basic Cloud Programming

THE CLOUD, CLOUD COMPUTING, AND THE CLOUD OPTIMIZED STACK

CLOUD PATTERNS AND BEST PRACTICES

USING MICROSOFT AZURE C# LIBRARIES TO CREATE A STORAGE CONTAINER

CREATING AN ASP.NET 4.7 WEB SITE THAT USES THE STORAGE CONTAINER

17 Advanced Cloud Programming and Deployment

CREATING AN ASP.NET WEB API

DEPLOYING AND CONSUMING AN ASP.NET WEB API ON MICROSOFT AZURE

SCALING AN ASP.NET WEB API ON MICROSOFT AZURE

18 .NET Standard and .NET Core

CROSS‐PLATFORM BASICS AND KEY “MUST KNOW” TERMS

WHAT IS .NET STANDARD, AND WHY IS IT NEEDED?

REFERENCING AND TARGETING FRAMEWORKS

WHAT IS .NET CORE?

BUILDING AND PACKAGING A .NET STANDARD LIBRARY

BUILDING A .NET CORE APPLICATION WITH VISUAL STUDIO

PORTING FROM .NET FRAMEWORK TO .NET CORE

19 ASP.NET and ASP.NET Core

OVERVIEW OF WEB APPLICATIONS

WHICH ASP.NET TO USE AND WHY

USING ASP.NET WEB FORMS

CREATING ASP.NET CORE WEB APPLICATIONS

PART IV: Data Access

20 Files

FILE CLASSES FOR INPUT AND OUTPUT

STREAMS

MONITORING THE FILE SYSTEM

21 XML and JSON

XML BASICS

JSON BASICS

XML SCHEMAS

XML DOCUMENT OBJECT MODEL

CONVERTING XML TO JSON

SEARCHING XML WITH XPATH

22 LINQ

LINQ TO XML

LINQ PROVIDERS

LINQ QUERY SYNTAX

LINQ METHOD SYNTAX

ORDERING QUERY RESULTS

UNDERSTANDING THE ORDERBY CLAUSE

QUERYING A LARGE DATA SET

USING AGGREGATE OPERATORS

USING THE SELECT DISTINCT QUERY

ORDERING BY MULTIPLE LEVELS

USING GROUP QUERIES

USING JOINS

23 Databases

USING DATABASES

INSTALLING SQL SERVER EXPRESS

ENTITY FRAMEWORK

A CODE FIRST DATABASE

BUT WHERE IS MY DATABASE?

NAVIGATING DATABASE RELATIONSHIPS

HANDLING MIGRATIONS

CREATING AND QUERYING XML FROM AN EXISTING DATABASE

PART V: Additional Techniques

24 Windows Communication Foundation

WHAT IS WCF?

WCF CONCEPTS

WCF PROGRAMMING

25 Universal Apps

GETTING STARTED

WINDOWS UNIVERSAL APPS

APP CONCEPTS AND DESIGN

APP DEVELOPMENT

COMMON ELEMENTS OF WINDOWS STORE APPS

THE WINDOWS STORE

Appendix: Exercise Solutions

CHAPTER 3 SOLUTIONS

CHAPTER 4 SOLUTIONS

CHAPTER 5 SOLUTIONS

CHAPTER 6 SOLUTIONS

CHAPTER 7 SOLUTIONS

CHAPTER 8 SOLUTIONS

CHAPTER 9 SOLUTIONS

CHAPTER 10 SOLUTIONS

CHAPTER 11 SOLUTIONS

CHAPTER 12 SOLUTIONS

CHAPTER 13 SOLUTIONS

CHAPTER 14 SOLUTIONS

CHAPTER 15 SOLUTIONS

CHAPTER 16 SOLUTIONS

CHAPTER 17 SOLUTIONS

CHAPTER 20 SOLUTIONS

CHAPTER 21 SOLUTIONS

CHAPTER 22 SOLUTIONS

CHAPTER 23 SOLUTIONS

CHAPTER 24 SOLUTIONS

CHAPTER 25 SOLUTIONS

End User License Agreement

List of Tables

Chapter 3

TABLE 3‐1: Integer Types

TABLE 3‐2: Floating‐Point Types

TABLE 3‐3: Text and Boolean Types

TABLE 3‐4: Literal Values

TABLE 3‐5: Escape Sequences for String Literals

TABLE 3‐6: Simple Mathematical Operators

TABLE 3‐7: The String Concatenation Operator

TABLE 3‐8: Increment and Decrement Operators

TABLE 3‐9: Assignment Operators

TABLE 3‐10: Operator Precedence

Chapter 4

TABLE 4‐1: Boolean Comparison Operators

TABLE 4‐2: Conditional Boolean Operators

TABLE 4‐3: Boolean Assignment Operators

TABLE 4‐4: Operator Precedence (Updated)

Chapter 5

TABLE 5‐1: Implicit Numeric Conversions

Chapter 9

TABLE 9-1: Access Modifiers for Class Definitions

TABLE 9-2: Methods of System.Object

TABLE 9-3: Class View Icons

TABLE 9-4: Additional Class View Icons

Chapter 12

TABLE 12-1: Generic Collection Type

TABLE 12-2: Sorting with Generic Types

TABLE 12-3: Generic Type Constraints

Chapter 14

TABLE 14‐1: Common Control Events

TABLE 14‐2: Common Layout Panels

TABLE 14‐3: Image Control Properties

TABLE 14‐4: TextBox Properties

TABLE 14‐5: CheckBox Properties

TABLE 14‐6: RadioButton Properties

TABLE 14‐7: IsReadOnly and IsEditable Combinations

TABLE 14‐8: Other ComboBox Properties

TABLE 14‐9: Interesting ListBox Properties

TABLE 14‐10: The Name Property

Chapter 15

TABLE 15‐1: The Register( ) Method's Parameters

TABLE 15‐2: Overloads for the FrameworkPropertyMetadata Constructor

TABLE 15‐3: Displaying MenuItem Properties

TABLE 15‐4: Property and Field Names

TABLE 15‐5: Cards in Hand Dependency Properties

TABLE 15‐6: Game Decks Dependency Properties

Chapter 18

TABLE 18‐1: Cross‐Platform Key Terms

TABLE 18‐2: Summary of .NET Standard 2.0 Namespace and API Count

TABLE 18‐3: Summary of .NET Standard Supported Version

TABLE 18‐4: .NET Core Performance Improvements versus .NET Framework

Chapter 19

TABLE 19-1: Baseline ASP.NET Core on Kestrel performance

TABLE 19-2: Differences between Projects and Web Sites

TABLE 19-3: Examples of ASP.NET Server Controls

TABLE 19-4: Examples of ASP.NET Validation Controls

TABLE 19-5: ASP.NET Web Forms State Management Techniques

TABLE 19-6: Examples of Razor HtmlHelper methods

TABLE 19-7: Examples of ASP.NET Core Validation Attributes

TABLE 19-8: ASP.NET Core State Management Techniques

Chapter 20

TABLE 20‐1: File System Access Classes

TABLE 20‐2: Static Methods of the File Class

TABLE 20‐3: Static Methods of the Directory Class

TABLE 20‐4: FileSystemInfo Properties

TABLE 20‐5: FileInfo Properties

TABLE 20‐6: Properties Unique to the DirectoryInfo Class

TABLE 20‐7: Stream Classes

TABLE 20‐8: FileAccess Enumeration Members

TABLE 20‐9: FileMode Enumeration Members

TABLE 20‐10: FileSystemWatcher Properties

Chapter 21

TABLE 21-1: Common DOM Classes

TABLE 21-2: XmlElement Properties

TABLE 21-3: Three Ways to Get the Value of a Node

TABLE 21-4: Methods for Creating Nodes

TABLE 21-5: Methods for Inserting Nodes

TABLE 21-6: Methods for Removing Nodes

TABLE 21-7: Methods for Selecting Nodes

TABLE 21-8: Common XPath Operations

Chapter 22

TABLE 22‐1: Aggregate Operators for Numeric Results

Chapter 24

TABLE 24‐1: Binding Types

TABLE 24‐2: NET Default Bindings

TABLE 24‐3: DataContractAttribute Properties

TABLE 24‐4: DataMemberAttribute Properties

TABLE 24‐5: ServiceContractAttribute Properties

TABLE 24‐6: OperationContractAttribute Properties

List of Illustrations

Chapter 1

FIGURE 1‐1

FIGURE 1‐2

FIGURE 1‐3

FIGURE 1‐4

Chapter 2

FIGURE 2‐1

FIGURE 2‐2

FIGURE 2‐3

FIGURE 2‐4

FIGURE 2‐5

FIGURE 2‐6

FIGURE 2‐7

FIGURE 2‐8

FIGURE 2‐9

FIGURE 2‐10

FIGURE 2‐11

FIGURE 2‐12

FIGURE 2‐13

FIGURE 2‐14

Chapter 3

FIGURE 3‐1

FIGURE 3‐2

FIGURE 3‐3

FIGURE 3‐4

Chapter 4

FIGURE 4‐1

FIGURE 4‐2

FIGURE 4‐3

FIGURE 4‐4

FIGURE 4‐5

FIGURE 4‐6

FIGURE 4‐7

Chapter 5

FIGURE 5‐1

FIGURE 5‐2

FIGURE 5‐3

FIGURE 5‐4

FIGURE 5‐5

FIGURE 5‐6

FIGURE 5‐7

FIGURE 5‐8

FIGURE 5‐9

FIGURE 5‐10

FIGURE 5‐11

FIGURE 5‐12

FIGURE 5‐13

FIGURE 5‐14

FIGURE 5‐15

Chapter 6

FIGURE 6‐1

FIGURE 6‐2

FIGURE 6‐3

FIGURE 6‐4

FIGURE 6‐5

FIGURE 6‐6

FIGURE 6‐7

FIGURE 6‐8

FIGURE 6‐9

FIGURE 6‐10

FIGURE 6‐11

FIGURE 6‐12

Chapter 7

FIGURE 7‐1

FIGURE 7‐2

FIGURE 7‐3

FIGURE 7‐4

FIGURE 7‐5

FIGURE 7‐6

FIGURE 7‐7

FIGURE 7‐8

FIGURE 7‐9

FIGURE 7‐10

FIGURE 7‐11

FIGURE 7‐12

FIGURE 7‐13

FIGURE 7‐14

FIGURE 7‐15

FIGURE 7‐16

FIGURE 7‐17

FIGURE 7‐18

FIGURE 7‐19

FIGURE 7‐20

Chapter 8

FIGURE 8‐1

FIGURE 8‐2

FIGURE 8‐3

FIGURE 8‐4

FIGURE 8‐5

FIGURE 8‐6

FIGURE 8‐7

FIGURE 8‐8

FIGURE 8‐9

FIGURE 8‐10

FIGURE 8‐11

FIGURE 8‐12

FIGURE 8‐13

FIGURE 8‐14

FIGURE 8‐15

Chapter 9

FIGURE 9‐1

FIGURE 9‐2

FIGURE 9‐3

FIGURE 9‐4

FIGURE 9‐5

FIGURE 9‐6

FIGURE 9‐7

FIGURE 9‐8

FIGURE 9‐9

FIGURE 9‐10

FIGURE 9‐11

FIGURE 9‐12

FIGURE 9‐13

FIGURE 9‐14

Chapter 10

FIGURE 10‐1

FIGURE 10‐2

FIGURE 10‐3

FIGURE 10‐4

FIGURE 10‐5

FIGURE 10‐6

FIGURE 10‐7

FIGURE 10‐8

FIGURE 10‐9

FIGURE 10‐10

FIGURE 10‐11

FIGURE 10‐12

FIGURE 10‐13

FIGURE 10‐14

Chapter 11

FIGURE 11‐1

FIGURE 11‐2

FIGURE 11‐3

FIGURE 11‐4

FIGURE 11‐5

FIGURE 11‐6

FIGURE 11‐7

FIGURE 11‐8

Chapter 12

FIGURE 12‐1

FIGURE 12‐2

FIGURE 12‐3

FIGURE 12‐4

FIGURE 12‐5

Chapter 13

FIGURE 13‐1

FIGURE 13‐2

FIGURE 13‐3

FIGURE 13‐4

FIGURE 13‐5

FIGURE 13‐6

FIGURE 13‐7

FIGURE 13‐8

FIGURE 13‐9

FIGURE 13‐10

FIGURE 13‐11

FIGURE 13‐12

FIGURE 13‐13

FIGURE 13‐14

FIGURE 13‐15

FIGURE 13‐16

FIGURE 13‐17

FIGURE 13‐18

FIGURE 13‐19

FIGURE 13‐20

FIGURE 13‐21

Chapter 14

FIGURE 14‐1

FIGURE 14‐2

FIGURE 14‐3

FIGURE 14‐4

FIGURE 14‐5

FIGURE 14‐6

FIGURE 14‐7

FIGURE 14‐8

FIGURE 14‐9

FIGURE 14‐10

FIGURE 14‐11

FIGURE 14‐12

FIGURE 14‐13

Chapter 15

FIGURE 15‐1

FIGURE 15‐2

FIGURE 15‐3

FIGURE 15‐4

FIGURE 15‐5

Chapter 16

FIGURE 16‐1

FIGURE 16‐2

FIGURE 16‐3

FIGURE 16‐4

FIGURE 16‐5

FIGURE 16‐6

FIGURE 16‐7

FIGURE 16‐8

FIGURE 16‐9

FIGURE 16‐10

FIGURE 16‐11

FIGURE 16‐12

FIGURE 16‐13

FIGURE 16‐14

FIGURE 16‐15

Chapter 17

FIGURE 17‐1

FIGURE 17‐2

FIGURE 17‐3

FIGURE 17‐4

FIGURE 17‐5

FIGURE 17‐6

FIGURE 17‐7

FIGURE 17‐8

FIGURE 17‐9

FIGURE 17‐10

FIGURE 17‐11

FIGURE 17‐12

Chapter 18

FIGURE 18‐1

FIGURE 18‐2

FIGURE 18‐3

FIGURE 18‐4

FIGURE 18‐5

FIGURE 18‐6

FIGURE 18‐7

FIGURE 18‐8

FIGURE 18‐9

FIGURE 18‐10

FIGURE 18‐11

FIGURE 18‐12

FIGURE 18‐13

Chapter 19

FIGURE 19‐1

FIGURE 19‐2

FIGURE 19‐3

FIGURE 19‐4

FIGURE 19‐5

FIGURE 19‐6

FIGURE 19‐7

FIGURE 19‐8

FIGURE 19‐9

FIGURE 19‐10

FIGURE 19‐11

Chapter 20

FIGURE 20‐1

FIGURE 20‐2

FIGURE 20‐3

FIGURE 20‐4

FIGURE 20‐5

FIGURE 20‐6

FIGURE 20‐7

FIGURE 20‐8

Chapter 21

FIGURE 21‐1

FIGURE 21‐2

FIGURE 21‐3

FIGURE 21‐4

FIGURE 21‐5

FIGURE 21‐6

FIGURE 21‐7

FIGURE 21‐8

Chapter 23

FIGURE 23‐1

FIGURE 23‐2

FIGURE 23‐3

FIGURE 23‐4

FIGURE 23‐5

FIGURE 23‐6

FIGURE 23‐7

FIGURE 23‐8

FIGURE 23‐9

FIGURE 23‐10

FIGURE 23‐11

FIGURE 23‐12

FIGURE 23‐13

FIGURE 23‐14

FIGURE 23‐15

FIGURE 23‐16

FIGURE 23‐17

FIGURE 23‐18

FIGURE 23‐19

FIGURE 23‐20

Chapter 24

FIGURE 24‐1

FIGURE 24‐2

FIGURE 24‐3

FIGURE 24‐4

FIGURE 24‐5

Chapter 25

FIGURE 25‐1

FIGURE 25‐2

Guide

Cover

Table of Contents

Begin Reading

Pages

i

xxi

xxii

xxiii

xxiv

xxv

xxvi

xxvii

xxvii

1

3

4

5

6

7

8

9

10

11

12

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

531

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

759

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

ii

iii

iv

v

BEGINNING C# 7 Programming with Visual Studio® 2017

Benjamin PerkinsJacob Vibe HammerJon D. Reid

INTRODUCTION

THE C# LANGUAGE WAS UNVEILED TO THE WORLD when Microsoft announced the first version of its .NET Framework in July 2000. Since then its popularity has rocketed, and it has arguably become the language of choice for desktop, web, cloud, and cross‐platform developers who use the .NET Framework. Part of the appeal of C# comes from its clear syntax, which derives from C/C++ but simplifies some things that have previously discouraged some programmers. Despite this simplification, C# has retained the power of C++, and there is now no reason not to move into C#. The language is not difficult and it's a great one to learn elementary programming techniques with. This ease of learning, combined with the capabilities of the .NET Framework, make C# an excellent way to start your programming career.

The latest release of C# is C# 7 (included with version 4.7 of the .NET Framework), which builds on the existing successes and adds even more attractive features. The latest release of Visual Studio (Visual Studio 2017) and the Visual Studio Code 2017 line of development tools also bring many tweaks and improvements to make your life easier and to dramatically increase your productivity.

This book is intended to teach you about all aspects of C# programming, including the language itself, desktop, cloud, and cross‐platform programming, making use of data sources, and some new and advanced techniques. You'll also learn about the capabilities of Visual Studio 2017 and all the ways that this product can aid your application development.

The book is written in a friendly, mentor‐style fashion, with each chapter building on previous ones, and every effort is made to ease you into advanced techniques painlessly. At no point will technical terms appear from nowhere to discourage you from continuing; every concept is introduced and discussed as required. Technical jargon is kept to a minimum, but where it is necessary, it, too, is properly defined and laid out in context.

The authors of this book are all experts in their field and are all enthusiastic in their passion for both the C# language and the .NET Framework. Nowhere will you find a group of people better qualified to take you under their collective wing and nurture your understanding of C# from first principles to advanced techniques. Along with the fundamental knowledge it provides, this book is packed full of helpful hints, tips, exercises, and full‐fledged example code (available for download on this book's web page at www.wrox.com and at https://github.com/benperk/BeginningCSharp7) that you will find yourself returning to repeatedly as your career progresses.

We pass this knowledge on without begrudging it and hope that you will be able to use it to become the best programmer you can be. Good luck, and all the best!

WHO THIS BOOK IS FOR

This book is for everyone who wants to learn how to program in C# using the .NET Framework. It is for absolute beginners who want to give programming a try by learning a clean, modern, elegant programming language. But it is also for people familiar with other programming languages who want to explore the .NET platform, as well as for existing .NET developers who want to give Microsoft's .NET flagship language a try.

WHAT THIS BOOK COVERS

The early chapters cover the language itself, assuming no prior programming experience. If you have programmed in other languages before, much of the material in these chapters will be familiar. Many aspects of C# syntax are shared with other languages, and many structures are common to practically all programming languages (such as looping and branching structures). However, even if you are an experienced programmer, you will benefit from looking through these chapters to learn the specifics of how these techniques apply to C#.

If you are new to programming, you should start from the beginning, where you will learn basic programming concepts and become acquainted with both C# and the .NET platform that underpins it. If you are new to the .NET Framework but know how to program, you should read Chapter 1 and then skim through the next few chapters before continuing with the application of the C# language. If you know how to program but haven't encountered an object‐oriented programming language before, you should read the chapters from Chapter 8 onward.

Alternatively, if you already know the C# language, you might want to concentrate on the chapters dealing with the most recent .NET Framework and C# language developments, specifically the chapters on collections, generics, and C# language enhancements (Chapters 11 and 12).

The chapters in this book have been written with a dual purpose in mind: They can be read sequentially to provide a complete tutorial in the C# language, and they can be dipped into as required reference material.

In addition to the core material, starting with Chapter 3 most chapters also include a selection of exercises at the end, which you can work through to ensure that you have understood the material. The exercises range from simple multiple choice or true/false questions to more complex exercises that require you to modify or build applications. The answers to all the exercises are provided in the Appendix. You can also find these exercises as part of the wrox.com code downloads on this book's page at www.wrox.com.

This book also gives plenty of love and attention to coincide with the release of C# 7 and .NET 4.7. Every chapter received an overhaul, with less relevant material removed, and new material added. All of the code has been tested against the latest version of the development tools used, and all of the screenshots have been retaken in Windows 10 to provide the most current windows and dialog boxes. New highlights of this edition include the following:

Additional and improved code examples for you to try out

Coverage of everything that's new in C# 7 and .NET 4.7

Examples of programming .NET Core and ASP.NET Core for running cross‐platform

Examples of programming cloud applications and using Azure SDK to create and access cloud resources

HOW THIS BOOK IS STRUCTURED

This book is divided into six sections:

Introduction

—Purpose and general outline of the book's contents

The C# Language

—Covers all aspects of the C# language, from the fundamentals to object‐oriented techniques

Windows Programming

—How to write and deploy desktop applications with the Windows Presentation Foundation library (WPF)

Cloud and Cross‐Platform Programming

—Cloud and cross‐platform application development and deployment, including the creation and consumption of a Web API

Data Access

—How to use data in your applications, including data stored in files on your hard disk, data stored in XML format, and data in databases

Additional Techniques

—An examination of some extra ways to use C# and the .NET Framework, including Windows Communication Foundation (WCF) and Universal Windows Applications

The following sections describe the chapters in the five major parts of this book.

The C# Language (Chapters 1– 13 )

Chapter 1 introduces you to C# and how it fits into the .NET landscape. You'll learn the fundamentals of programming in this environment and how Visual Studio 2017 (VS) fits in.

Chapter 2 starts you off with writing C# applications. You'll look at the syntax of C# and put the language to use with sample command‐line and Windows applications. These examples demonstrate just how quick and easy it can be to get up and running, and along the way you'll be introduced to the Visual Studio development environment and the basic windows and tools that you'll be using throughout the book.

Next, you'll learn more about the basics of the C# language. You'll learn what variables are and how to manipulate them in Chapter 3. You'll enhance the structure of your applications with flow control (looping and branching) in Chapter 4, and you'll see some more advanced variable types such as arrays in Chapter 5. In Chapter 6 you'll start to encapsulate your code in the form of functions, which makes it much easier to perform repetitive operations and makes your code much more readable.

By the beginning of Chapter 7 you'll have a handle on the fundamentals of the C# language, and you will focus on debugging your applications. This involves looking at outputting trace information as your applications are executed, and at how Visual Studio can be used to trap errors and lead you to solutions for them with its powerful debugging environment.

From Chapter 8 onward you'll learn about object‐oriented programming (OOP), starting with a look at what this term means and an answer to the eternal question, “What is an object?” OOP can seem quite difficult at first. The whole of Chapter 8 is devoted to demystifying it and explaining what makes it so great, and you won't actually deal with much C# code until the very end of the chapter.

Everything changes in Chapter 9, when you put theory into practice and start using OOP in your C# applications. This is where the true power of C# lies. You'll start by looking at how to define classes and interfaces, and then move on to class members (including fields, properties, and methods) in Chapter 10. At the end of that chapter you'll start to assemble a card game application, which is developed over several chapters and will help to illustrate OOP.

Once you've learned how OOP works in C#, Chapter 11 moves on to look at common OOP scenarios, including dealing with collections of objects, and comparing and converting objects. Chapter 12 takes a look at a very useful feature of C# that was introduced in .NET 2.0: generics, which enable you to create very flexible classes. Next, Chapter 13 continues the discussion of the C# language and OOP with some additional techniques, notably events, which become very important in, for example, Windows programming. Chapter 13 wraps up the fundamentals by focusing on C# language features that were introduced with versions 3.0, 4, 5, and 6 of the language.

Windows Programming (Chapters 14– 15 )

Chapter 14 starts by introducing you to what is meant by Windows programming and looks at how this is achieved in Visual Studio. It focuses on WPF as a tool that enables you to build desktop applications in a graphical way and assemble advanced applications with the minimum of effort and time. You'll start with the basics of WPF programming and build up your knowledge in both this chapter and Chapter 15, which demonstrates how you can use the wealth of controls supplied by the .NET Framework in your applications.

Cloud and Cross‐Platform Programming (Chapters 16– 19 )

Chapter 16 starts by describing what cloud programming is and discusses the cloud‐optimized stack. The cloud environment is not identical to the way programs have been traditionally coded, so a few cloud programming patterns are discussed and defined. To complete this chapter, you require an Azure account, which is free, so that you can create an App Service Web App. Then, using the Azure SDK with C#, you create and access a storage account from an ASP.NET 4.7 web application.

In Chapter 17, you learn how to create and deploy an ASP.NET Web API to the cloud and then consume the Web API from a similar ASP.NET 4.7 web application. The chapter ends discussing two of the most valuable features in the cloud, scaling and the optimal utilization of hardware resources.

Chapter 18 introduces .NET Standard and .NET Core, which are tools used for targeting any application type—for example WPF, Windows, and ASP.NET. An emerging application is one that can run cross‐platform such as on Linux or MacOS. The chapter provides instructions for installing .NET Core 2.0 and creating and implementing a .NET Standard library.

Chapter 19 describes ASP.NET and its many different types (e.g., ASP.NET Webforms, ASP.NET MVC, and ASP.NET Core). The exercises in this chapter utilize the .NET Standard library created in Chapter 18 from both an ASP.NET Webpage and an ASP.NET Core application.

Data Access (Chapters 20– 23 )

Chapter 20 looks at how your applications can save and retrieve data to disk, both as simple text files and as more complex representations of data. You'll also learn how to compress data and how to monitor and act on file system changes.

In Chapter 21 you'll learn about the de facto standard for data exchange—namely XML—and a rapidly emerging format called JSON. By this point in the book, you'll have touched on XML several times in preceding chapters, but this chapter lays out the ground rules and shows you what all the excitement is about.

The remainder of this part looks at LINQ, which is a query language built in to the latest versions of the .NET Framework. You start in Chapter 22 with a general introduction to LINQ, and then you will use LINQ to access a database and other data in Chapter 23.

Additional Techniques (Chapters 24– 25 )

Chapter 24 is an introduction to Windows Communication Foundation (WCF), which provides you with the tools you need for enterprise‐level programmatic access to information and capabilities across local networks and the Internet. You will see how you can use WCF to expose complex data and functionality to web and desktop applications in a platform‐independent way.

Chapter 25 shows you how you can create Universal Windows Apps, which are new to Windows. This chapter builds on the foundation of Chapters 14 and 15 to show you how to create Windows Apps that can run on all windows platforms.

WHAT YOU NEED TO USE THIS BOOK

The code and descriptions of C# and the .NET Framework in this book apply to C# 7 and .NET 4.7. You don't need anything other than the Framework to understand this aspect of the book, but many of the examples require a development tool. This book uses Visual Studio Community 2017 as its primary development tool. Use Visual Studio Community 2017 to create Windows, cloud, and cross‐platform applications as well as SQL Server Express for applications that access databases. Some functionality is available only in Visual Studio 2017, but this won't stop you from working through any of the examples in this book.

The source code for the samples is available for download from this book's page on www.wrox.com and at https://github.com/benperk/BeginningCSharp7.

CONVENTIONS

To help you get the most from the text and keep track of what's happening, we've used a number of conventions throughout the book.

TRY IT OUT

The Try It Out is an exercise you should work through, following the text in the book.

These exercises usually consist of a set of steps.

Each step has a number.

Follow the steps through with your copy of the database.

How It Works

After each Try It Out, the code you've typed will be explained in detail.

WARNING

Warnings hold important, not‐to‐be‐forgotten information that is directly relevant to the surrounding text.

NOTE

Shaded boxes like this hold notes, tips, hints, tricks, or asides to the current discussion.

As for styles in the text:

We

italicize

new terms and important words when we introduce them.

We show keyboard strokes like this: Ctrl+A.

We show file names, URLs, and code within the text like so:

persistence.properties

We present code in two different ways:

We use a monofont type with no highlighting for most code examples.

We use bold to emphasize code that is particularly important in the present

context or to show changes from a previous code snippet.

SOURCE CODE

As you work through the examples in this book, you may choose either to type in all the code manually, or to use the source code files that accompany the book. All the source code used in this book is available for download on this book's page at www.wrox.com and at https://github.com/benperk/BeginningCSharp7.

You can also search for the book at www.wrox.com by ISBN (the ISBN for this book is 978‐1‐119‐45868‐5) to find the code. A complete list of code downloads for all current Wrox books is available at www.wrox.com/dynamic/books/download.aspx.

Most of the code on www.wrox.com is compressed in a .ZIP, .RAR archive, or similar archive format appropriate to the platform. Once you download the code, just decompress it with an appropriate compression tool.

NOTE

Because many books have similar titles, you may find it easiest to search by ISBN; this book's ISBN is 978‐1‐119‐45868‐5.

Alternatively, as just mentioned, you can also go to the main Wrox code download page atwww.wrox.com/dynamic/books/download.aspx to see the code available for this book and all other Wrox books.

ERRATA

We make every effort to ensure that there are no errors in the text or in the code. However, no one is perfect, and mistakes do occur. If you find an error in one of our books, like a spelling mistake or faulty piece of code, we would be very grateful for your feedback. By sending in errata, you may save another reader hours of frustration, and at the same time, you will be helping us provide even higher quality information.

To find the errata page for this book, go to this book's page at www.wrox.com and click the Errata link. On this page you can view all errata that has been submitted for this book and posted by Wrox editors.

If you don't spot “your” error on the Book Errata page, go to www.wrox.com/contact/techsupport.shtml and complete the form there to send us the error you have found. We'll check the information and, if appropriate, post a message to the book's errata page and fix the problem in subsequent editions of the book.

PART IThe C# Language

CHAPTER 1: Introducing C#

CHAPTER 2: Writing a C# Program

CHAPTER 3: Variables and Expressions

CHAPTER 4: Flow Control

CHAPTER 5: More about Variables

CHAPTER 6: Functions

CHAPTER 7: Debugging and Error Handling

CHAPTER 8: Introduction to Object-Oriented Programming

CHAPTER 9: Defining Classes

CHAPTER 10: Defining Class Members

CHAPTER 11: Collections, Comparisons, and Conversions

CHAPTER 12: Generics

CHAPTER 13: Additional C# Techniques

1Introducing C#

WHAT YOU WILL LEARN IN THIS CHAPTER

What the .NET Framework is

What C# is

Explore Visual Studio 2017

Welcome to the first chapter of the first section of this book. This section provides you with the basic knowledge you need to get up and running with the most recent version of C#. Specifically, this chapter provides an overview of the .NET Framework and C#, including what these technologies are, the motivation for using them, and how they relate to each other.

It begins with a general discussion of the .NET Framework. This technology contains many concepts that are tricky to come to grips with initially. This means that the discussion, by necessity, covers many concepts in a short amount of space. However, a quick look at the basics is essential to understanding how to program in C#. Later in the book, you revisit many of the topics covered here, exploring them in more detail.

After that general introduction, the chapter provides a basic description of C# itself, including its origins and similarities to C++. Finally, you look at the primary tool used throughout this book: Visual Studio (VS). Visual Studio 2017 is the latest in a long line of development environments that Microsoft has produced, and it includes all sorts of features (including full support for Windows Store, Azure, and cross‐platform applications) that you will learn about throughout this book.

WHAT IS THE .NET FRAMEWORK?

The .NET Framework (now at version 4.7) is a revolutionary platform created by Microsoft for developing applications. The most interesting thing about this statement is how vague and limited it is—but there are good reasons for this. To begin with, note that it doesn't actually “develop applications only on the Windows operating system.” Although the Microsoft release of the .NET Framework runs on the Windows and Windows Mobile operating systems, it is possible to find alternative versions that will work on other systems. One example of this is Mono, an open source version of the .NET Framework (including a C# compiler) that runs on several operating systems, including various ‐flavors of Linux and Mac OS; you can read more about it at http://www.mono‐project.com.

Mono is a very important part of the .NET ecosystem, especially for creating client‐side applications with Xamarin. Microsoft has also created a cross platform open source library called .NET Core (https://github.com/dotnet/core) which they hope will have a positive impact on both the Mono and .NET Core frameworks. Programmers in both ecosystems can use examples from each other's libraries to improve performance, security, and the breadth of language feature offerings—collaboration is a key characteristic in the open source community.

In addition, the definition of the .NET Framework includes no restriction on the type of applications that are possible. The .NET Framework enables the creation of desktop applications, Windows Store (UWP) applications, cloud/web applications, Web APIs, and pretty much anything else you can think of. Also, it's worth noting that web, cloud, and Web API applications are, by definition, multi‐platform applications, since any system with a web browser can access them.

The .NET Framework has been designed so that it can be used from any language, including C# (the subject of this book) as well as C++, F#, JScript, Visual Basic, and even older languages such as COBOL. For this to work, .NET‐specific versions of these languages have also appeared, and more are being released all the time. For a list of languages, see https://msdn.microsoft.com/en‐us/library/ee822860(v=vs.100).aspx. Not only do these languages have access to the .NET Framework, but they can also communicate with each other. It is possible for C# developers to make use of code written by Visual Basic programmers, and vice versa.

All of this provides an extremely high level of versatility and is part of what makes using the .NET Framework such an attractive prospect.

What's in the .NET Framework?

The .NET Framework consists primarily of a gigantic library of code that you use from your client‐ or server‐side languages (such as C#) using object‐oriented programming (OOP) techniques. This library is categorized into different modules—you use portions of it depending on the results you want to achieve. For example, one module contains the building blocks for Windows applications, another for network programming, and another for web development. Some modules are divided into more specific submodules, such as a module for building web services within the module for web development.

The intention is for different operating systems to support some or all of these modules, depending on their characteristics. A smartphone, for example, includes support for all the base .NET functionality, but is unlikely to require some of the more esoteric modules.

Part of the .NET Framework library defines some basic types. A type is a representation of data, and specifying some of the most fundamental of these (such as “a 32‐bit signed integer”) facilitates interoperability between languages using the .NET Framework. This is called the Common Type System (CTS).

As well as supplying this library, the .NET Framework also includes the .NET Common Language Runtime (CLR), which is responsible for the execution of all applications developed using the.NET library.

.NET Standard and .NET Core

When the .NET Framework was originally created, although it was designed for running on multiple platforms, there was no industry accepted open‐source forking concept. These days, usually on GitHub, a project can be forked and then customized to run on multiple platforms. For example, the .NET Compact Framework and the .NET Micro Framework are forks of the .NET Framework, like .NET Core, which was created as the most optimal solution for cross‐platform code development. Each of those .NET Framework “flavors” or “verticals” had a specific set of requirements and objectives that triggered the need to make that fork.

Included in the .NET Framework is a set of Base Class Libraries (BCL) that contain APIs for basic actions most developers need a program to do. These actions include, for example, file access, string manipulation, managing streams, storing data in collections, security attributes, and many others. These fundamental capabilities are often implemented differently within each of the .NET Framework flavors. This requires a developer to learn, develop, and manage multiple BCLs for each fork or flavor of their application based on the platform it runs. This is the problem that the .NET Standard has solved.

The expectation is that shortly, this forking concept will result in many more flavors of the .NET Framework. This increase will necessitate a standard set of basic programming APIs that works with each fork and flavor. Without this cross platform base library, the development and support complexities would prevent the speedy adoption of the forked version. In short, .NET Standard is a class library that exposes APIs that support any fork or flavor of application using the .NET Platform.

Writing Applications Using the .NET Framework and .NET Core

Writing an application using either the .NET Framework or .NET Core means writing code (using any of the languages that support the Framework) using the .NET code library. In this book you use Visual Studio for your development. Visual Studio is a powerful, integrated development environment that supports C# (as well as managed and unmanaged C++, Visual Basic, and some others). The advantage of this environment is the ease with which .NET features can be integrated into your code. The code that you create will be entirely C# but use the .NET Framework throughout, and you'll make use of the additional tools in Visual Studio where necessary.

In order for C# code to execute, it must be converted into a language that the target operating ‐system understands, known as native code. This conversion is called compiling code, an act that is performed by a compiler. Under the .NET Framework and .NET Core, this is a two‐stage process.

CIL and JIT

When you compile code that uses either the .NET Framework or .NET Core library, you don't immediately create operating system–specific native code. Instead, you compile your code into Common Intermediate Language (CIL) code. This code isn't specific to any operating system (OS) and isn't specific to C#. Other .NET languages—Visual Basic .NET or F#, for example—also compile to this language as a first stage. This compilation step is carried out by Visual Studio when you develop C# applications.

Obviously, more work is necessary to execute an application. That is the job of a just‐in‐time (JIT) compiler, which compiles CIL into native code that is specific to the OS and machine architecture being targeted. Only at this point can the OS execute the application. The just‐in‐time part of the name reflects the fact that CIL code is compiled only when it is needed. This compilation can happen on the fly while your application is running, although luckily this isn't something that you normally need to worry about as a developer. Unless you are writing extremely advanced code where performance is critical, it's enough to know that this compilation process will churn along merrily in the background, without interfering.

In the past, it was often necessary to compile your code into several applications, each of which targeted a specific operating system and CPU architecture. Typically, this was a form of optimization (to get code to run faster on an AMD chipset, for example), but at times it was critical (for applications to work in both Win9x and WinNT/2000 environments, for example). This is now unnecessary because JIT compilers (as their name suggests) use CIL code, which is independent of the machine, operating system, and CPU. Several JIT compilers exist, each targeting a different architecture, and the CLR/CoreCLR uses the appropriate one to create the native code required.

The beauty of all this is that it requires a lot less work on your part—in fact, you can forget about system‐dependent details and concentrate on the more interesting functionality of your code.

NOTE

As you learn about .NET you might come across references to Microsoft Intermediate Language (MSIL). MSIL was the original name for CIL, and many developers still use this terminology today. Seehttps://en.wikipedia.org/wiki/Common_Intermediate_Languagefor more information about CIL.

Assemblies

When you compile an application, the CIL code is stored in an assembly. Assemblies include both executable application files that you can run directly from Windows without the need for any other programs (these have an .exe file extension) and libraries (which have a .dll extension) for use by other applications.

In addition to containing CIL, assemblies also include meta information (that is, information about the information contained in the assembly, also known as metadata) and optional resources (additional data used by the CIL, such as sound files and pictures). The meta information enables assemblies to be fully self‐descriptive. You need no other information to use an assembly, meaning you avoid situations such as failing to add required data to the system registry and so on, which was often a problem when developing with other platforms.

This means that deploying applications is often as simple as copying the files into a directory on a remote computer. Because no additional information is required on the target systems, you can just run an executable file from this directory and, assuming the .NET CLR is installed for .NET Framework targeted applications, you're good to go. For .NET Core targeted applications, all modules required to run the program are included in the deployment package and therefore no additional configurations are required.

From a .NET Framework perspective, you won't necessarily want to include everything required to run an application in one place. You might write some code that performs tasks required by multiple applications. In situations like that, it is often useful to place the reusable code in a place accessible to all applications. In the .NET Framework, this is the global assembly cache (GAC). Placing code in the GAC is simple—you just place the assembly containing the code in the directory containing this cache.

Managed Code

The role of the CLR/CoreCLR doesn't end after you have compiled your code to CIL and a JIT compiler has compiled that to native code. Code written using the .NET Framework and .NET Core are managed when it is executed (a stage usually referred to as runtime). This means that the CLR/CoreCLR looks after your applications by managing memory, handling security, allowing cross‐language debugging, and so on. By contrast, applications that do not run under the control of the CLR/CoreCLR are said to be unmanaged, and certain languages such as C++ can be used to write such applications, which, for example, access low‐level functions of the operating system. However, in C# you can write only code that runs in a managed environment. You will make use of the managed features of the CLR/CoreCLR and allow .NET itself to handle any interaction with the operating system.

Garbage Collection

One of the most important features of managed code is the concept of garbage collection. This is the .NET method of making sure that the memory used by an application is freed up completely when the application is no longer in use. Prior to .NET this was mostly the responsibility of programmers, and a few simple errors in code could result in large blocks of memory mysteriously disappearing as a result of being allocated to the wrong place in memory. That usually meant a progressive slowdown of your computer, followed by a system crash.

.NET garbage collection works by periodically inspecting the memory of your computer and removing anything from it that is no longer needed. There is no set time frame for this; it might happen thousands of times a second, once every few seconds, or whenever, but you can rest assured that it will happen.

There are some implications for programmers here. Because this work is done for you at an unpredictable time, applications have to be designed with this in mind. Code that requires a lot of memory to run should tidy itself up, rather than wait for garbage collection to happen, but that isn't as tricky as it sounds.

Fitting It Together

Before moving on, let's summarize the steps required to create a .NET application as discussed previously:

Application code is written using a .NET‐compatible language such as C# (see

Figure 1‐1

).

That code is compiled into CIL, which is stored in an assembly (see

Figure 1‐2

).

When this code is executed (either in its own right if it is an executable or when it is used from other code), it must first be compiled into native code using a JIT compiler (see

Figure 1‐3

).

The native code is executed in the context of the managed CLR/CoreCLR, along with any other running applications or processes, as shown in

Figure 1‐4

.

FIGURE 1‐1

FIGURE 1‐2

FIGURE 1‐3

FIGURE 1‐4

Linking

Note one additional point concerning this process. The C# code that compiles into CIL in step 2 needn't be contained in a single file. It's possible to split application code across multiple source‐code files, which are then compiled together into a single assembly. This extremely useful process is known as linking. It is required because it is far easier to work with several smaller files than one enormous one. You can separate logically related code into an individual file so that it can be worked on independently and then practically forgotten about when completed. This also makes it easy to locate specific pieces of code when you need them and enables teams of developers to divide the programming burden into manageable chunks, whereby individuals can “check out” pieces of code to work on without risking damage to otherwise satisfactory sections or sections other people are working on.

WHAT IS C#?

C#, as mentioned earlier, is one of the languages you can use to create applications that will run in the .NET CLR/CoreCLR. It is an evolution of the C and C++ languages and has been created by Microsoft specifically to work with the .NET platform. The C# language has been designed to incorporate many of the best features from other languages, while clearing up their problems.

Developing applications using C# is simpler than using C++ because the language syntax is simpler. Still, C# is a powerful language, and there is little you might want to do in C++ that you can't do in C#. Having said that, those features of C# that parallel the more advanced features of C++, such as directly accessing and manipulating system memory, can be carried out only by using code marked as unsafe. This advanced programmatic technique is potentially dangerous (hence its name) because it is possible to overwrite system‐critical blocks of memory with potentially catastrophic results. For this reason, and others, this book does not cover that topic.

At times, C# code is slightly more verbose than C++. This is a consequence of C# being a typesafe language (unlike C++). In layperson's terms, this means that once some data has been assigned to a type, it cannot subsequently transform itself into another unrelated type. Consequently, strict rules must be adhered to when converting between types, which means you will often need to write more code to carry out the same task in C# than you might write in C++. However, there are benefits to this—the code is more robust, debugging is simpler, and .NET can always track the type of a piece of data at any time. In C#, you therefore might not be able to do things such as “take the region of memory 4 bytes into this data and 10 bytes long and interpret it as X,” but that's not necessarily a bad thing.

C# is just one of the languages available for .NET development, but it is certainly the best. It has the advantage of being the only language designed from the ground up for the .NET Framework and is the principal language used in versions of .NET that are ported to other operating systems. To keep languages such as the .NET version of Visual Basic as similar as possible to their predecessors yet compliant with the CLR/CoreCLR, certain features of the .NET code library are not fully supported, or at least require unusual syntax.

By contrast, C# can make use of every feature that the .NET Framework code library has to offer, but not all features have been ported to .NET Core. Also, each new version of .NET has included additions to the C# language, partly in response to requests from developers, making it even more powerful.

Applications You Can Write with C#

The .NET Framework has no restrictions on the types of applications that are possible, as discussed earlier. C# uses the framework and therefore has no restrictions on possible applications. (However, currently it is possible to write only Console and ASP.NET applications using .NET Core.) However, here are a few of the more common application types:

Desktop applications