Beginning C# and .NET

INTRODUCTION

THE C# LANGUAGE WAS UNVEILED TO THE WORLD when Microsoft announced the first version of its .NET Framework in 2002. 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 .NET. 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 no reason now not to move into C#. The language is not difficult, and it is a great one with which to learn elementary programming techniques. 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# 9 (included with.NET 5.0 and .NET Framework 4.8), which builds on the existing successes and adds even more attractive features. The latest releases of both Visual Studio and Visual Studio Code 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 will also learn about the capabilities of Visual Studio 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 both experts in their field and are enthusiastic in their passion for the C# language and .NET. Nowhere will you find two 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.wiley.com and at github.com/benperk/BeginningCSharpAndDotNET) 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 .NET. 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 by 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 .NET 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 have not 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 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 for 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 wiley.com code downloads on this book's page at www.wiley.com.

Every chapter receives an overhaul with every new release of C# and .NET, the less relevant material is removed, and new material added. All the code has been tested against the latest version of the development tools used, and all the screenshots have been retaken in the most current version of the Windows OS 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

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

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

HOW THIS BOOK IS STRUCTURED

This book is divided into four 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

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 .NET, including cloud and cross‐platform development, ASP.NET Web API, Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), and Universal Windows Applications

The following sections describe the chapters in the three 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 will learn the fundamentals of programming in this environment and how Visual Studio (VS) fits in.

Chapter 2 starts you off with writing C# applications. You will 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 will be introduced to the Visual Studio development environment and the basic windows and tools that you'll be using throughout the book.

Next, you will learn more about the basics of the C# language. You will learn what variables are and how to manipulate them in Chapter 3. You will enhance the structure of your applications with flow control (looping and branching) in Chapter 4, and you will see some more advanced variable types such as arrays in Chapter 5. In Chapter 6 you will 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 will 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 will 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 OOP and explaining what makes it so great, and you will not 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 will 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 will start to assemble a card game application, which is developed over several chapters and will help to illustrate OOP.

Once you have 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 looks at a 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 important in, for example, Windows programming. Chapter 13 wraps up the fundamentals by focusing on C# language features that were introduced in some of the more recent versions of C#.

Data Access (Chapters 14–17)

Chapter 14 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 will also learn how to compress data and how to monitor and act on file system changes.

In Chapter 15 you will 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 will 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 into .NET. You start in Chapter 16 with a general introduction to LINQ, and then you will use LINQ to access a database and other data in Chapter 17.

Additional Techniques (Chapters 18–21)

Chapter 18 introduces .NET Standard and .NET Core, which are tools used for targeting any application type—for example, Windows Presentation Foundation (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 and creating and implementing a .NET Standard library. Additionally, descriptions of ASP.NET and its many different types (e.g., ASP.NET Webforms, ASP.NET MVC, and ASP.NET Core) are covered.

Chapter 19 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 trail account, which is free to create and comes with some credits so that you can create and test out an App Service Web App. Then, using the Azure SDK with C#, you create and access a storage account from an ASP.NET web application.

In Chapter 20, you learn how to create an ASP.NET Web API and consume it using a Blazor WebAssembly App. Then this chapter provides 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 21 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 (Windows Presentation Foundation) as a tool that enables you to build desktop applications in a graphical way and assemble advanced applications with a minimum of effort and time. You will start with the basics of WPF programming and build up your knowledge to more advanced concepts.

WHAT YOU NEED TO USE THIS BOOK

The code and descriptions of C# and .NET in this book apply to C# 9 and .NET 4.8. You do not need anything other than .NET to understand this aspect of the book, but many of the examples require a development tool. This book uses the most current version of Visual Studio Community 2019 as its primary development tool. Use Visual Studio Community 2019 to create Windows, cloud, and cross‐platform applications as well as SQL Server Express for applications that access databases.

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

CONVENTIONS

To help you get the most from the text and keep track of what is 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 to the end.

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 filenames, 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.wiley.com and at github.com/benperk/BeginningCSharpAndDotNET.

Most of the code on www.wiley.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‐79578‐0.

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.wiley.com and click the Errata link. On this page you can view all errata that have been submitted for this book.

PART I

The 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

1

Introducing C#

WHAT YOU WILL LEARN IN THIS CHAPTER

What .NET is

What C# is

Explore Visual Studio

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

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

After this general .NET 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 is an Integrated Development Environment (IDE) that Microsoft has produced since the late 1990s and gets updated regularly with new features. Visual Studio includes all sorts of capabilities including full support for desktop, cloud, web, mobile, database, machine learning, AI, and cross-platform programming that you will learn about throughout this book.

WHAT IS .NET?

.NET is a revolutionary software framework created by Microsoft for developing computer programs. To begin with, note that .NET provides more than the means for creating programs that target the Windows operating system. .NET is fully open source and fully supports running cross platform. Cross platform means that the code you write using .NET will run on Linux and MacOS operating systems as well. The source code for .NET is open source and you can find it at github.com/dotnet/core.

The .NET software framework is made of prewritten computer code, which provides simple access to basic computing resources like the hard drive and computer memory. One aspect of this framework is referred to as the Base Class Library (BCL), which contains the System class. You will become very familiar with it as you progress through this book. Taking a deeper look into the source code inside the System class, you will find that it includes the definitions of data types like strings, integers, Boolean, and characters . If you need one of these data types in your program to store information, you can use the already written .NET code to achieve that. If such code did not already exist, you would need to use low-level programming languages like assembly or machine code to allocate and manage the required memory yourself. The basic types found in the System class also facilitate interoperability between .NET programming languages, a concept referred to as the Common Type System (CTS). Interoperability means that a string in C# has the same attributes and behaviors as a string in Visual Basic or F#. Besides supplying this source code library, .NET also includes the Common Language Runtime (CLR), which is responsible for the execution of all applications developed using the .NET library; more on that later.

In addition to the System class, .NET contains many, many other classes, often called modules. Some would say it is a gigantic library of object-oriented programming (OOP) code categorized into different modules—you use portions of it depending on the results you want to achieve. For example, System.IO and System.Text are the classes you would use to read and write to files located on a computer hard drive. A programmer can manipulate the contents of a file simply by using the code that already exists in the System.IO class without needing to manage handles or load the file from the hard drive into memory. There exist many classes in .NET that help programmers write programs at a fast pace, because all of the low-level code required to achieve their tasks has already been written. The programmer only needs the knowledge of which classes they require to achieve the program objectives.

Not only does .NET speed up application development, but it also can be utilized by numerous other programming languages, not just C# (which is the subject of this book). Programs written in C++, F#, Visual Basic, and even older languages such as COBOL can use the classes that exist in .NET. These languages have access to the code in the .NET library, but the code written in one programming language can communicate with code from another. For example, a program written in C# can make use of code written in Visual Basic or F# and vice versa. All of these examples are what makes .NET such an attractive prospect for building customized software.

.NET Framework, .NET Standard, and .NET Core

When the .NET Framework was originally created, it targeted the Windows operating system platform. Through the years, the .NET Framework code was forked to support numerous other platforms like IoT devices, desktops, mobile devices, and other operating systems. You may recognize some of the branches going by the names of .NET Compact Framework, .NET Portable, or .NET Micro Framework. Each of these forks contained its own, slightly modified BCL. Take note that a BCL is more than just strings, Booleans, and integers . It includes capabilities like file access, string manipulation, managing streams, storing data in collections, security attributes, and many others.

Having even a slightly different BCL required a programmer to learn, develop, and manage the subtle difference between the BCLs for each .NET fork. Each fork of the .NET Framework that targeted desktops, the Internet, or mobile platforms could have significant implementation differences, even though each program used .NET. It was (and still is) very common for a company to have desktop, website, and phone applications that ran the same program logic but did so on those different platforms. In that scenario, using .NET required a version of the company's application for each platform. That was not efficient. This is the problem that the .NET Standard solved. The .NET Standard provided a place for programmers to create application logic that could be used across any of the .NET Framework forks. The .NET Standard made the different platforms, like desktop, mobile, and web, BCL agnostic by decoupling a company's program logic from platform-specific dependencies.

.NET Core was the open source, cross-platform version of the .NET library. This fork of the code could be used to create programs that targeted numerous different platforms and operating systems like Linux, MacOS, and of course Windows. It was also the fork that would eventually become the one and only maintained branch of the .NET source code library. As of 2020, knowing about the .NET Framework, .NET Standard, and .NET Core is no longer as relevant as it once was. These three branches of .NET must be mentioned here because you will still likely see them, read about them, and be confronted with them for some years to come. It is important that you know what they are and their purpose, in case you need to work on a project that implements them. As of 2020, there is a new version of .NET simply named .NET. .NET is fully open source, is fully cross platform, and can be used on many platforms without having to support multiple versions, forks, and branches of your program.

Writing Programs Using .NET

Creating a computer program with .NET means writing code that uses existing code found within the .NET library. In this book you use Visual Studio for developing your programs. Visual Studio is a powerful, integrated development environment that supports C# (as well as C++, Visual Basic, F#, 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 .NET throughout, and also some additional tools in Visual Studio, where necessary. 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, an act that is performed by a compiler, which is a two-stage process.

CIL and JIT

When you compile code that uses .NET, 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 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. See en.wikipedia.org/wiki/Common_Intermediate_Language for more information about CIL (also known as Intermediate Language [IL]).

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 CLR is installed for .NET targeted applications, you're good to go. Depending on the deployment scenario, the modules required to run the program are included in the deployment package which means no additional configurations.

From a .NET perspective, you won't necessarily want to include everything required to run an application in a single directory. You might write some code that performs tasks required by multiple applications. In situations like these, it is often useful to place the reusable code in a place accessible to all applications. In .NET, this place 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 doesn't end after you have compiled your code to CIL and a JIT compiler has compiled that to native code. Code written using .NET is managed when it is executed (a stage usually referred to as runtime). This means that the CLR 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 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 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 using it. 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).

FIGURE 1-1

That code is compiled into CIL, which is stored in an assembly (see Figure 1-2).

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).

FIGURE 1-3

The native code is executed in the context of the managed CLR, along with any other running applications or processes, as shown in Figure 1-4.

FIGURE 1-4

Linking

Note one additional point concerning this process. The C# code that compiles into CIL in step 2 need not be contained in a single file. It is 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. This 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. This allows individuals to 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. 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 .NET 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, 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 the .NET code library has to offer. 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#

.NET has no restrictions on the types of applications that are possible. C# uses the framework and therefore has no restrictions on possible applications. However, here are a few of the more common application types:

Desktop applications—Applications, such as Microsoft Office, that have a familiar Windows look and feel about them. This is made simple by using the Windows Presentation Foundation (WPF) module of .NET, which is a library of controls (such as buttons, toolbars, menus, and so on) that you can use to build a Windows user interface (UI).

Cloud/web applications—.NET includes a powerful system named ASP.NET Core, for generating web content dynamically, enabling personalization, security, and much more. Additionally, these applications can be hosted and accessed in the cloud, for example on the Microsoft Azure platform.

Mobile applications—Using both C# and Xamarin mobile UI framework you can target mobile applications that target the Android operating system.

Web APIs—An ideal framework for building RESTful HTTP services that support a broad variety of clients, including mobile devices and browsers. These are also referred to as REST APIs.

WCF services—A way to create versatile distributed applications. With WCF, you can exchange virtually any data over local networks or the Internet, using the same simple syntax regardless of the language used to create a service or the system on which it resides. This is an older technology that would require an older version of the .NET Framework to create.

Any of these types of applications might also require some form of database access, which can be achieved using the ADO.NET (Active Data Objects .NET) feature set of .NET, through the Entity Framework, or through the LINQ (Language Integrated Query) capabilities of C#. Many other resource assemblies can be utilized that are helpful with creating networking components, outputting graphics, performing complex mathematical tasks, and so on.

C# in This Book

Part I of this book deals with the syntax and usage of the C# language without too much emphasis on .NET. This is necessary because you cannot use .NET at all without a firm grounding in C# programming. You will start off even simpler, in fact, and leave the more involved topic of OOP until you have covered the basics. These are taught from first principles, assuming no programming knowledge at all.

After that, you will be ready to move on to developing more complex (but more useful) applications. Part II examines data access (for ORM database concepts, filesystem, and XML data) and LINQ. Part III explores additional techniques like REST API, the cloud, and Windows Desktop.

VISUAL STUDIO

In this book, you use the most recent version of the Visual Studio development tool for all of your C# programming, from simple command-line applications to more complex project types. A development tool, or Integrated Development Environment (IDE), such as Visual Studio is not essential for developing C# applications, but it makes things much easier. You can (if you want to) manipulate C# source code files in a basic text editor, such as the ubiquitous Notepad application, and compile code into assemblies using the command-line compiler that is part of .NET. However, why do this when you have the power of an IDE to help you?

Visual Studio Products

Microsoft supplies several versions of Visual Studio. For example:

Visual Studio Community

Visual Studio Professional

Visual Studio Enterprise

Visual Studio Code

Visual Studio for Mac

Visual Studio Code, Mac, and Community are freely available at visualstudio.microsoft.com/downloads. The Professional and Enterprise versions have additional capabilities, which carry a cost.

The various Visual Studio products enable you to create almost any C# application you might need. Visual Studio Code is a simple yet robust code editor that runs on Windows, Linux, and iOS. Visual Studio Community, unlike Visual Studio Code, retains the same look and feel as Visual Studio Professional and Enterprise. Microsoft offers many of the same features in Visual Studio Community as exist in the Professional and Enterprise versions; however, some notable features are absent, like deep debugging capabilities and code optimization tools. However, not so many features are absent that you cannot use Community to work through the chapters of this book. Visual Studio Community is the version of the IDE used to work the examples in this book.

Solutions

When you use Visual Studio to develop applications, you do so by creating solutions. A solution, in Visual Studio terms, is more than just an application. Solutions contain projects, which might be Console Applications, WPF projects, Cloud/Web Application projects, ASP.NET Core projects, and so on. Because solutions can contain multiple projects, you can group together related code in one place, even if it will eventually compile to multiple assemblies in various places on your hard disk.

This is especially useful because it enables you to work on shared code (which might be placed in the GAC) at the same time as applications that use this code. Debugging code is a lot easier when only one development environment is used because you can step through instructions in multiple code modules.

▸WHAT YOU LEARNED IN THIS CHAPTER

2

Writing a C# Program

WHAT YOU WILL LEARN IN THIS CHAPTER

Understanding Visual Studio basics

Writing a simple console application

Writing a simple desktop application

CODE DOWNLOADS FOR THIS CHAPTER

The code downloads for this chapter are found on the book page at www.wiley.com. Click the Downloads link. The code can also be found at github.com/benperk/BeginningCSharpAndDotNET. The code is in the Chapter02 folder and individually named according to the names throughout the chapter.

Now that you have spent some time learning what C# is and how it fits into .NET, it's time to get your hands dirty and write some code. You use Visual Studio Community (VS) throughout this book, so the first thing to do is have a look at some of the basics of this development environment.

Visual Studio is an enormous and complicated product, and it can be daunting to first-time users, but using it to create basic applications can be surprisingly simple. As you start to use Visual Studio in this chapter, you will see that you do not need to know a huge amount about it to begin playing with C# code. Later in the book you will see some of the more complicated operations that Visual Studio can perform, but for now a basic working knowledge is all that is required.

After you have looked at the IDE, you put together two simple applications. You do not need to worry too much about the code in these applications for now; you just want to prove that things work. By working through the application-creation procedures in these early examples, they will become second nature before too long.

You will learn how to create two basic types of applications in this chapter: a console application and a desktop application.

The first application you create is a simple console application. Console applications do not use the graphical windows environment, so you will not have to worry about buttons, menus, interaction with the mouse pointer, and so on. Instead, you run the application in a command prompt window and interact with it in a much simpler way.

The second application is a desktop application, which you create using Windows Presentation Foundation (WPF). The look and feel of a desktop application is very familiar to Windows users, and (surprisingly) the application doesn't require much more effort to create. However, the syntax of the code required is more complicated, even though in many cases you do not have to worry about details.

You use both types of applications in Part II and Part III of the book, with more emphasis on console applications at the beginning. The additional flexibility of desktop applications isn't necessary when you are learning the C# language, while the simplicity of console applications enables you to concentrate on learning the syntax without worrying about the look and feel of the application.

THE VISUAL STUDIO DEVELOPMENT ENVIRONMENT

When you begin the installation of Visual Studio Community you are prompted with a window similar to Figure 2-1. It provides a list of workloads, individual components, and language packs to install along with the core editor.

Check the following Workloads and click the Install button:

Desktop & Mobile—.NET desktop development

.NET Framework 4.8 development tools

Web & Cloud—ASP.NET and web development

Web & Cloud—Azure development

Other Toolsets—.NET Core cross-platform development

After installation is complete, when Visual Studio is first loaded, it immediately presents you with the option to Sign in to Visual Studio using your Microsoft Account. By doing this, your Visual Studio settings are synced between devices so that you do not have to configure the IDE when using it on multiple workstations. If you do not have a Microsoft Account, follow the process for the creation of one and then use it to sign in. If you do not want to sign in, click the Not now, maybe later link, and continue the initial configuration of Visual Studio. It is recommended that at some point you sign in and get a developer license.

If this is the first time you've run Visual Studio, you will be presented with a list of preferences intended for users who have experience with previous releases of this development environment. The choices you make here affect a number of things, such as the layout of windows, the way that console windows run, and so on. Therefore, choose Visual C# from the drop-down; otherwise, you might find that things don't quite work as described in this book. Note that the options available vary depending on the options you chose when installing Visual Studio, but as long as you chose to install C# this option will be available.

FIGURE 2-1

If this isn't the first time that you've run Visual Studio, and you chose a different option the first time, don't panic. To reset the settings to Visual C#, you simply have to import them. To do this, select Tools ➪ Import and Export Settings, and choose the Reset All Settings option, shown in Figure 2-2.

FIGURE 2-2

Click Next, and indicate whether you want to save your existing settings before proceeding. If you have customized things, you might want to do this; otherwise, select No and click Next again. From the next dialog box, select Visual C#, as shown in Figure 2-3. Again, the available options may vary.

FIGURE 2-3

Finally, click Finish, then Close to apply the settings.

The Visual Studio environment layout is completely customizable, but the default is fine here. With C# Developer Settings selected, it is arranged as shown in Figure 2-4.

The main window is where all your code is displayed and will be different depending on which kind of solution you are creating. The one illustrated in Figure 2-4 is an ASP.NET Core Web Application; the startup page provides some links and additional information relevant to that application type. This window can contain many documents, each indicated by a tab, so you can easily switch between several files by clicking their filenames. It also has other functions: It can display GUIs that you are designing for your projects, plain-text files, HTML, and various tools that are built into Visual Studio. You will come across all of these in the course of this book.

Above the main window are toolbars and the Visual Studio menu. Several different toolbars can be placed here, with functionality ranging from saving and loading files to building and running projects to debugging controls. Again, you are introduced to these as you need to use them.

FIGURE 2-4

Here are brief descriptions of each of the main features that you will use the most:

The Toolbox window pops up when you click its tab. It provides access to, among other things, the user interface building blocks for desktop applications. Another tab, Server Explorer, can also appear here (selectable via the View ➪ Server Explorer menu option) and includes various additional capabilities, such as Azure subscription details, providing access to data sources, server settings, services, and more.

The Solution Explorer window displays information about the currently loaded solution. A solution, as you learned in the previous chapter, is Visual Studio terminology for one or more projects along with their configurations. The Solution Explorer window displays various views of the projects in a solution, such as what files they contain and what is contained in those files.

The Git Changes window displays information about the current Git Repository connection. This allows you access to source control, bug tracking, build automation, and other functionality. However, this is an advanced subject and is not covered in this book.

Just below the Solution Explorer window, you can display a Properties window, shown in Figure 2-4; it appears only when you are working on a project (you can also toggle its display using View ➪ Properties Window). This window provides a more detailed view of the project's contents, enabling you to perform additional configuration of individual elements. For example, you can use this window to change the appearance of a button in a desktop application.

Also not shown in the screenshot is another extremely important window: the Error List window, which you can display using View ➪ Error List. It shows errors, warnings, and other project-related information. The window updates continuously, although some information appears only when a project is compiled.

This might seem like a lot to take in, but it doesn't take long to get comfortable. You start by building the first of your example projects, which involves many of the Visual Studio elements just described.

NOTE Visual Studio is capable of displaying many other windows, both informational and functional. Many of these can share screen space with the windows mentioned here, and you can switch between them using tabs, dock them elsewhere, or even detach them and place them on other displays if you have multiple monitors. Several of these windows are used later in the book, and you'll probably discover more yourself when you explore the Visual Studio environment in more detail.

CONSOLE APPLICATIONS

You use console applications regularly in this book, particularly at the beginning, so the following Try It Out provides a step-by-step guide to creating a simple one.

TRY IT OUT Creating a Simple Console Application: ConsoleApp1\Program.cs

Create a new Console Application project by selecting File ➪ New ➪ Project, as shown in Figure 2-5.

FIGURE 2-5

Ensure that C# is selected from the All Languages drop-down and choose the Console Application project (see Figure 2-6). Click the Next button and Change the Location text box to C:\BeginningCSharpAndDotNET\Chapter02 (this directory is created automatically if it does not already exist). Leave the default text in the Name text box ( ConsoleApp1 ) and the other settings as they are.

FIGURE 2-6

Select .NET 5.0 from the Target Framework dropdown then click the Create button.

Once the project is initialized, add the following lines of code to the Program.cs file displayed in the main window:

    namespace ConsoleApp1    {      class Program      {          static void Main(string[] args)          {// Output text to the screen.Console.WriteLine(The first app in Beginning C# and .NET!);Console.ReadKey();          }      }    }

Select the Debug ➪ Start Debugging menu item. After a few moments, you should see the window shown in Figure 2-7.

FIGURE 2-7

Press any key to exit the application (you might need to click on the console window to focus on it first). The display in Figure 2-7 appears only if the Visual C# Developer Settings are applied, as described earlier in this chapter. For example, with Visual Basic Developer Settings applied, an empty console window is displayed, and the application output appears in a window labeled Immediate . In this case, the Console.ReadKey() code also fails, and you see an error. If you experience this problem, the best solution for working through the examples in this book is to apply the Visual C# Developer Settings—that way, the results you see match the results shown here.

How It Works

For now, I will not dissect the code used thus far because the focus here is on how to use the development tools to get code up and running. Clearly, Visual Studio does a lot of the work for you and makes the process of compiling and executing code simple. In fact, there are multiple ways to perform even these basic steps—for instance, you can create a new project by using the menu item mentioned earlier, by pressing Ctrl+Shift+N, or by clicking the corresponding icon in the toolbar.

Similarly, your code can be compiled and executed in several ways. The process you used in the example—selecting Debug ➪ Start Debugging—also has a keyboard shortcut (F5) and a toolbar icon. You can also run code without being in debugging mode using the Debug ➪ Start Without Debugging menu item (or by pressing Ctrl+F5), or compile your project without running it (with debugging on or off) using Build ➪ Build Solution or pressing F6. Note that you can execute a project without debugging or build a project using toolbar icons, although these icons do not appear on the toolbar by default. After you have compiled your code, you can also execute it simply by running the . exe file produced in Windows Explorer, or from the command prompt. To do this, open a command prompt window, change the directory to C:\BeginningCSharpAndDotNET\Chapter02\ConsoleApp1\ConsoleApp1\bin\Debug\net5.0, type ConsoleApp1, and press Enter.

NOTE In future examples, when you see the instructions create a new console project or execute the code, you can choose whichever method you want to perform these steps. Unless otherwise stated, all code should be run with debugging enabled. In addition, the terms start, execute, and run are used interchangeably in this book, and the discussions following the examples always assume that you have exited the application in the example.

Console applications terminate as soon as they finish execution, which can mean that you do not get a chance to see the results if you run them directly through the IDE. To get around this in the preceding example, the code is told to wait for a key press before terminating, using the following line:

        Console.ReadKey();

You will see this technique used many times in later examples. Now that you've created a project, you can take a more detailed look at some of the regions of the development environment.

The Solution Explorer

By default, the Solution Explorer window is docked in the top-right corner of the screen. As with other windows, you can move it wherever you like, or you can set it to auto-hide by clicking the pin icon. The Solution Explorer window shares space with another useful window called Class View, which you can display using View ➪ Class View. Figure 2-8 shows both of these windows with all nodes expanded (you can toggle between them by clicking the tabs at the bottom of the window when the window is docked).

FIGURE 2-8

This Solution Explorer view shows the files that make up the ConsoleApp1 project. The file to which you added code, Program.cs, is shown along with the project Dependencies.

NOTE All C# code files have a .cs file extension.

You can use this window to change what code is displayed in the main window by double-clicking .cs files; right-clicking them and selecting View Code; or selecting them and clicking the toolbar button that appears at the top of the window. You can also perform other operations on files here, such as renaming them or deleting them from your project. Other file types can also appear here, such as project resources (resources are files used by the project that might not be C# files, such as bitmap images and sound files). Again, you can manipulate them through the same interface.

You can also expand code items such as Program.cs to see what is contained. This overview of your code structure can be a very useful tool; it also enables you to navigate directly to specific parts of your code file, instead of opening the code file and scrolling to the part you want.

The Dependencies entry contains a list of the .NET libraries you are using in your project. You will look at this later; the standard references are fine for now. Class View presents an alternative view of your project by showing the structure of the code you created. You'll come back to this later in the book; for now, the Solution Explorer display is appropriate. As you click files or other icons in these windows, notice that the contents of the Properties window (shown in Figure 2-9) changes.

FIGURE 2-9

The Properties Window

The Properties window (select View ➪ Properties Window if it is not already displayed) shows additional information about whatever you select in the window above it. For example, the view shown in Figure 2-9 is displayed when the Program.cs file from the project is selected. This window also displays information about other selected items, such as user interface components (as shown in the Desktop Applications section of this chapter).

Often, changes you make to entries in the Properties window affect your code directly, adding lines of code or changing what you have in your files. With some projects, you spend as much time manipulating things through this window as making manual code changes.

The Error List Window

Currently, the Error List window (View ➪Error List) isn't showing anything interesting because there is nothing wrong with the application. However, this is a particularly useful window indeed. As a test, remove the semicolon from one of the lines of code you added in the previous section. After a moment, you should see a display like the one shown in Figure 2-10.

FIGURE 2-10

In addition, the project will no longer compile.

NOTE In Chapter 3, when you start looking at C# syntax, you will learn that semicolons are expected throughout your code—at the end of most lines, in fact.

This window helps you eradicate bugs in your code because it keeps track of what you must do to compile projects. If you double-click the error shown here, the cursor jumps to the position of the error in your source code (the source file containing the error will be opened if it isn't already open), so you can fix it quickly. Red wavy lines appear at the positions of errors in the code, so you can quickly scan the source code to see where problems lie.

The error location is specified as a line number. By default, line numbers are not displayed in the Visual Studio text editor, but that is something well worth turning on. To do so, tick the Line Numbers check box in the Options