Target Audience for This Book

My challenge with this book was to keep advanced developers awake while not abandoning beginners by using words such as assembly, link, chain, thread, and fusion as though the topic was more appropriate for blacksmiths than for programmers. This book’s primary audience is experienced developers looking to add another language to their quiver. However, I have carefully assembled this book to provide significant value to developers at all levels.

• Beginners: If you are new to programming, this book serves as a resource to help transition you from an entry-level programmer to a C# developer who is comfortable with any C# programming task that’s thrown your way. This book not only teaches you syntax but also trains you in good programming practices that will serve you throughout your programming career.

• Structured programmers: Just as it’s best to learn a foreign language through immersion, learning a computer language is most effective when you begin using it before you know all the intricacies. In this vein, this book begins with a tutorial that will be comfortable for those familiar with structured programming, and by the end of Chapter 5, developers in this category should feel at home writing basic control flow programs. However, the key to excellence for C# developers is not memorizing syntax. To transition from simple programs to enterprise development, the C# developer must think natively in terms of objects and their relationships. To this end, Chapter 6’s Beginner Topics introduce classes and object-oriented development. The role of historically structured programming languages such as C, COBOL, and FORTRAN is still significant but shrinking, so it behooves software engineers to become familiar with object-oriented development. C# is an ideal language for making this transition because it was designed with object-oriented development as one of its core tenets.

• Object-based and object-oriented developers: C++, Java, Python, TypeScript, Visual Basic, and Java programmers fall into this category. Many of you are already completely comfortable with semicolons and curly braces. A brief glance at the code in Chapter 1 reveals that, at its core, C# is like other C- and C++-style languages that you already know.

• C# professionals: For those already versed in C#, this book provides a convenient reference for less frequently encountered syntax. Furthermore, it provides insight into language details and subtleties that are seldom addressed. Most important, it presents the guidelines and patterns for programming robust and maintainable code. This book also aids in the task of teaching C# to others. With the emergence of C# 3.0 through 8.0, some of the most prominent enhancements are

  – String interpolation (see Chapter 2)

  – Implicitly typed variables (see Chapter 3)

  – Tuples (see Chapter 3)

  – Nullable reference types (see Chapter 3)

  – Pattern matching (see Chapter 4)

  – Extension methods (see Chapter 6)

  – Partial methods (see Chapter 6)

  – Default interface members (see Chapter 8)

  – Anonymous types (see Chapter 12)

  – Generics (see Chapter 12)

  – Lambda statements and expressions (see Chapter 13)

  – Expression trees (see Chapter 13)

  – Standard query operators (see Chapter 15)

  – Query expressions (see Chapter 16)

  – Dynamic programming (Chapter 18)

  – Multithreaded programming with the Task Programming Library and async (Chapter 20)

  – Parallel query processing with PLINQ (Chapter 21)

  – Concurrent collections (Chapter 22)

These topics are covered in detail for those not already familiar with them. Also pertinent to advanced C# development is the subject of pointers, covered in Chapter 23. Even experienced C# developers often do not understand this topic well.

Features of This Book

Essential C# 8.0 is a language book that adheres to the core C# Language Specification. To help you understand the various C# constructs, it provides numerous examples demonstrating each feature. Accompanying each concept are guidelines and best practices, ensuring that code compiles, avoids likely pitfalls, and achieves maximum maintainability.

To improve readability, code is specially formatted and chapters are outlined using mind maps.

Code Samples

The code snippets in most of this text can run on most implementations of the Common Language Infrastructure (CLI), but the focus is on the Microsoft .NET Framework and the .NET Core implementation. Platform- or vendor-specific libraries are seldom used except when communicating important concepts relevant only to those platforms (e.g., appropriately handling the single-threaded user interface of Windows). Any code that specifically relates to C# 5.0, 6.0, 7.0, or 8.0 is called out in the C# version indexes at the end of the book.

Here is a sample code listing.

Begin 2.0

Listing 1.19: Commenting Your Code

The formatting is as follows.

• Comments are shown in italics.

  Click here to view code image

  /* Display a greeting to the console
     using composite formatting */

• Keywords are shown in bold.

  static void Main()

• Highlighted code calls out specific code snippets that may have changed from an earlier listing, or demonstrates the concept described in the text.

  Click here to view code image

     System.Console.WriteLine(valerie);
     miracleMax = "It would take a miracle.";                      
     System.Console.WriteLine(miracleMax);

  Highlighting can appear on an entire line or on just a few characters within a line.

  Click here to view code image

        System.Console.WriteLine(
            $"The palindrome "{palindrome}" is"
            + $" {palindrome.Length} characters.");

• Incomplete listings contain an ellipsis to denote irrelevant code that has been omitted.

        // ...

• Console output is the output from a particular listing that appears following the listing. User input for the program appears in boldface.

Output 1.7

Click here to view code image

Hey you!
Enter your first name: Inigo
Enter your last name: Montoya

Your full name is Inigo Montoya.

Although it might have been convenient to provide full code samples that you could copy into your own programs, doing so would detract from your learning a particular topic. Therefore, you need to modify the code samples before you can incorporate them into your programs. The core omission is error checking, such as exception handling. Also, code samples do not explicitly include using System statements. You need to assume the statement throughout all samples.

You can find sample code at https://IntelliTect.com/EssentialCSharp.

Mind Maps

Each chapter’s introduction includes a mind map, which serves as an outline that provides an at-a-glance reference to each chapter’s content. Here is an example (taken from Chapter 6).

The theme of each chapter appears in the mind map’s center. High-level topics spread out from the core. Mind maps allow you to absorb the flow from high-level to more detailed concepts easily, with less chance of encountering very specific knowledge that you might not be looking for.

How This Book Is Organized

At a high level, software engineering is about managing complexity, and it is toward this end that I have organized Essential C# 8.0. Chapters 1–5 introduce structured programming, which enable you to start writing simple functioning code immediately. Chapters 6–10 present the object-oriented constructs of C#. Novice readers should focus on fully understanding this section before they proceed to the more advanced topics found in the remainder of this book. Chapters 12–14 introduce additional complexity-reducing constructs, handling common patterns needed by virtually all modern programs. This leads to dynamic programming with reflection and attributes, which is used extensively for threading and interoperability in the chapters that follow.

The book ends with Chapter 24 on the Common Language Infrastructure, which describes C# within the context of the development platform in which it operates. This chapter appears at the end because it is not C# specific and it departs from the syntax and programming style in the rest of the book. However, this chapter is suitable for reading at any time, perhaps most appropriately immediately following Chapter 1.

Here is a description of each chapter (in this list, chapter numbers shown in bold indicate the presence of C# 7.0-8.0 material).

• Chapter 1, Introducing C#: After presenting the C# HelloWorld program, this chapter proceeds to dissect it. This should familiarize readers with the look and feel of a C# program and provide details on how to compile and debug their own programs. It also touches on the context of a C# program’s execution and its intermediate language.

• Chapter 2, Data Types: Functioning programs manipulate data, and this chapter introduces the primitive data types of C#.

• Chapter 3, More with Data Types: This chapter includes coverage of two type categories, value types and reference types. From there, it delves into implicitly typed local variables, tuples, the nullable modifier, and the C# 8.0–introduced feature, nullable reference types. It concludes with an in-depth look at a primitive array structure.

• Chapter 4, Operators and Control Flow: To take advantage of the iterative capabilities in a computer, you need to know how to include loops and conditional logic within your program. This chapter also covers the C# operators, data conversion, and preprocessor directives.

• Chapter 5, Methods and Parameters: This chapter investigates the details of methods and their parameters. It includes passing by value, passing by reference, and returning data via an out parameter. In C# 4.0, default parameter support was added, and this chapter explains how to use default parameters.

• Chapter 6, Classes: Given the basic building blocks of a class, this chapter combines these constructs to form fully functional types. Classes form the core of object-oriented technology by defining the template for an object. This chapter also includes the nullable attributes newly introduced in C# 8.0.

• Chapter 7, Inheritance: Although inheritance is a programming fundamental to many developers, C# provides some unique constructs, such as the new modifier. This chapter discusses the details of the inheritance syntax, including overriding.

• Chapter 8, Interfaces: This chapter demonstrates how interfaces are used to define the versionable interaction contract between classes. C# includes both explicit and implicit interface member implementation, enabling an additional encapsulation level not supported by most other languages. With the introduction of default interface members, there is a new section on interface versioning in C# 8.0.

• Chapter 9, Value Types: Although not as prevalent as defining reference types, it is sometimes necessary to define value types that behave in a fashion similar to the primitive types built into C#. This chapter describes how to define structures while exposing the idiosyncrasies they may introduce.

• Chapter 10, Well-Formed Types: This chapter discusses more advanced type definition. It explains how to implement operators, such as + and casts, and describes how to encapsulate multiple classes into a single library. In addition, the chapter demonstrates defining namespaces and XML comments and discusses how to design classes for garbage collection.

• Chapter 11, Exception Handling: This chapter expands on the exception-handling introduction from Chapter 5 and describes how exceptions follow a hierarchy that enables creating custom exceptions. It also includes some best practices on exception handling.

• Chapter 12, Generics: Generics are perhaps the core feature missing from C# 1.0. This chapter fully covers this 2.0 feature. In addition, C# 4.0 added support for covariance and contravariance—something covered in the context of generics in this chapter.

• Chapter 13, Delegates and Lambda Expressions: Delegates begin clearly distinguishing C# from its predecessors by defining patterns for handling events within code. This virtually eliminates the need for writing routines that poll. Lambda expressions are the key concept that make C# 3.0’s LINQ possible. This chapter explains how lambda expressions build on the delegate construct by providing a more elegant and succinct syntax. This chapter forms the foundation for the collection API discussed next.

• Chapter 14, Events: Encapsulated delegates, known as events, are a core construct of the Common Language Runtime. Anonymous methods, another C# 2.0 feature, are also presented here.

• Chapter 15, Collection Interfaces with Standard Query Operators: The simple and yet elegantly powerful changes introduced in C# 3.0 begin to shine in this chapter as we take a look at the extension methods of the Enumerable class. This class makes available a collection API known as the standard query operators, which is discussed in detail here.

• Chapter 16, LINQ with Query Expressions: Using standard query operators alone results in some long statements that are hard to decipher. However, query expressions provide an alternative syntax that matches closely with SQL, as described in this chapter.

• Chapter 17, Building Custom Collections: In building custom APIs that work against business objects, it is sometimes necessary to create custom collections. This chapter details how to do this and in the process introduces contextual keywords that make custom collection building easier.

• Chapter 18, Reflection, Attributes, and Dynamic Programming: Object-oriented programming formed the basis for a paradigm shift in program structure in the late 1980s. In a similar way, attributes facilitate declarative programming and embedded metadata, ushering in a new paradigm. This chapter looks at attributes and discusses how to retrieve them via reflection. It also covers file input and output via the serialization framework within the Base Class Library. In C# 4.0, a new keyword, dynamic, was added to the language. This removed all type checking until runtime, a significant expansion of what can be done with C#.

• Chapter 19, Introducing Multithreading: Most modern programs require the use of threads to execute long-running tasks while ensuring active response to simultaneous events. As programs become more sophisticated, they must take additional precautions to protect data in these advanced environments. Programming multithreaded applications is complex. This chapter introduces how to work with tasks, including canceling them, and how to handle exceptions executing in the task context.

• Chapter 20, Programming the Task-Based Asynchronous Pattern: This chapter delves into the task-based asynchronous pattern with its accompanying async/await syntax. It provides a significantly simplified approach to multithreaded programming. In addition, the C# 8.0 concept of asynchronous streams is included.

• Chapter 21, Iterating in Parallel: One easy way to introduce performance improvements is by iterating through data in parallel using a Parallel object or with the Parallel LINQ library.

• Chapter 22, Thread Synchronization: Building on the preceding chapter, this chapter demonstrates some of the built-in threading pattern support that can simplify the explicit control of multithreaded code.

• Chapter 23, Platform Interoperability and Unsafe Code: Given that C# is a relatively young language, far more code is written in other languages than in C#. To take advantage of this preexisting code, C# supports interoperability—the calling of unmanaged code—through P/Invoke. In addition, C# provides for the use of pointers and direct memory manipulation. Although code with pointers requires special privileges to run, it provides the power to interoperate fully with traditional C-based application programming interfaces.

• Chapter 24, The Common Language Infrastructure: Fundamentally, C# is the syntax that was designed as the most effective programming language on top of the underlying Common Language Infrastructure. This chapter delves into how C# programs relate to the underlying runtime and its specifications.

• Indexes of C# 6.0, 7.0, and 8.0: These indexes provide quick references for the features added in C# 6.0 through 8.0. They are specifically designed to help programmers quickly update their language skills to a more recent version.

I hope you find this book to be a great resource in establishing your C# expertise and that you continue to reference it for those areas that you use less frequently well after you are proficient in C#.

—Mark Michaelis
IntelliTect.com/mark
Twitter: @Intellitect, @MarkMichaelis