Bibliography C# .NET DevOps JavaScript Software Engineering

B01N3C5ECP ISBN-13: 978-1787286610

See: Continuous Integration, Delivery, and Deployment: Reliable and faster software releases with automating builds, tests, and deployment, Publisher ‏ : ‎ Packt Publishing (October 30, 2017)

Fair Use Source:

Cloud DevOps DevSecOps-Security-Privacy Linux Software Engineering

DevOps toolchain

See also: CloudOps, toolchain

“A DevOps toolchain is a set or combination of tools that aid in the delivery, development, and management of software applications throughout the systems development life cycle, as coordinated by an organization that uses DevOps practices.

Generally, DevOps tools fit into one or more activities, which supports specific DevOps initiatives: Plan, Create, Verify, Package, Release, Configure, Monitor, and Version Control.[1][2]” (WP)


“In software, a toolchain is the set of programming tools that is used to perform a complex software development task or to create a software product, which is typically another computer program or a set of related programs. In general, the tools forming a toolchain are executed consecutively so the output or resulting environment state of each tool becomes the input or starting environment for the next one, but the term is also used when referring to a set of related tools that are not necessarily executed consecutively.[3][4][5]

As DevOps is a set of practices that emphasizes the collaboration and communication of both software developers and other information technology (IT) professionals, while automating the process of software delivery and infrastructure changes, its implementation can include the definition of the series of tools used at various stages of the lifecycle; because DevOps is a cultural shift and collaboration between development and operations, there is no one product that can be considered a single DevOps tool. Instead a collection of tools, potentially from a variety of vendors, are used in one or more stages of the lifecycle.[6][7]” (WP)

Stages of DevOps

Further information: DevOps


Plan is composed of two things: “define” and “plan”.[8] This activity refers to the business value and application requirements. Specifically “Plan” activities include:

  • Production metrics, objects and feedback
  • Requirements
  • Business metrics
  • Update release metrics
  • Release plan, timing and business case
  • Security policy and requirement

A combination of the IT personnel will be involved in these activities: business application owners, software developmentsoftware architects, continual release management, security officers and the organization responsible for managing the production of IT infrastructure.


Create is composed of the building (see also build automation), coding, and configuring of the software development process.[8] The specific activities are:

Tools and vendors in this category often overlap with other categories. Because DevOps is about breaking down silos, this is reflective in the activities and product solutions.[clarification needed]


Verify is directly associated with ensuring the quality of the software release; activities designed to ensure code quality is maintained and the highest quality is deployed to production.[8] The main activities in this are:

Solutions for verify related activities generally fall under four main categories: Test automation , Static analysis , Test Lab, and Security.


Packaging refers to the activities involved once the release is ready for deployment, often also referred to as staging or Preproduction / “preprod”.[8] This often includes tasks and activities such as:

  • Approval/preapprovals
  • Package configuration
  • Triggered releases
  • Release staging and holding


Release related activities include schedule, orchestration, provisioning and deploying software into production and targeted environment.[9] The specific Release activities include:

  • Release coordination
  • Deploying and promoting applications
  • Fallbacks and recovery
  • Scheduled/timed releases

Solutions that cover this aspect of the toolchain include application release automation, deployment automation and release management.


Configure activities fall under the operation side of DevOps. Once software is deployed, there may be additional IT infrastructure provisioning and configuration activities required.[8] Specific activities including:

  • Infrastructure storage, database and network provisioning and configuring
  • Application provision and configuration.

The main types of solutions that facilitate these activities are continuous configuration automationconfiguration management, and infrastructure as code tools.[10]


Monitoring is an important link in a DevOps toolchain. It allows IT organization to identify specific issues of specific releases and to understand the impact on end-users.[8] A summary of Monitor related activities are:

  • Performance of IT infrastructure
  • End-user response and experience
  • Production metrics and statistics

Information from monitoring activities often impacts Plan activities required for changes and for new release cycles.

Version Control

Version Control is an important link in a DevOps toolchain and a component of software configuration management. Version Control is the management of changes to documents, computer programs, large web sites, and other collections of information.[8] A summary of Version Control related activities are:

  • Non-linear development
  • Distributed development
  • Compatibility with existent systems and protocols
  • Toolkit-based design

Information from Version Control often supports Release activities required for changes and for new release cycles.

See also


  1. ^ Edwards, Damon. “Integrating DevOps tools into a Service Delivery Platform”
  2. ^ Seroter, Richard. “Exploring the ENTIRE DevOps Toolchain for (Cloud) Teams”
  3. ^ “Toolchain Overview” 2012-01-03. Retrieved 2013-10-21.
  4. ^ “Toolchains” 2013-09-08. Retrieved 2013-10-21.
  5. ^ Imran, Saed; Buchheit, Martin; Hollunder, Bernhard; Schreier, Ulf (2015-10-29). Tool Chains in Agile ALM Environments: A Short IntroductionLecture Notes in Computer Science9416. pp. 371–380. doi:10.1007/978-3-319-26138-6_40ISBN 978-3-319-26137-9.
  6. ^ Loukides, Mike (2012-06-07). “What is DevOps?”.
  7. ^ Garner Market Trends: DevOps – Not a Market, but Tool-Centric Philosophy That supports a Continuous Delivery Value Chain (Report). Gartner. 18 February 2015.
  8. a b c d e f g Avoid Failure by Developing a Toolchain that Enables DevOps (Report). Gartner. 16 March 2016.
  9. ^ Best Practices in Change, Configuration and Release Management (Report). Gartner. 14 July 2010.
  10. ^ Roger S. Pressman (2009). Software Engineering: A Practitioner’s Approach (7th International ed.). New York: McGraw-Hill.



Fair Use Sources:

Bibliography C# .NET Software Engineering

C# .NET Bibliography

See also C# and .NET Framework and JavaScript Bibliography

Bibliography C# .NET Software Engineering

C# 9.0 in a Nutshell: The Definitive Reference

See also: C# .NET Bibliography and C# and .NET Framework

See: C# 9.0 in a Nutshell: The Definitive Reference, 1st Edition, by Joseph Albahari, 2021, B08XN578HZ (CSNS9)

Fair Use Source: B08XN578HZ (CSNS9)

About This Book:

When you have questions about C# 9.0 or .NET 5, this best-selling guide has the answers you need. C# is a language of unusual flexibility and breadth, but with its continual growth there’s so much more to learn. In the tradition of O’Reilly’s Nutshell guides, this thoroughly updated edition is simply the best one-volume reference to the C# language available today.

Organized around concepts and use cases, C# 9.0 in a Nutshell provides intermediate and advanced programmers with a concise map of C# and .NET that also plumbs significant depths.

  • Get up to speed on C#, from syntax and variables to advanced topics such as pointers, records, closures, and patterns
  • Dig deep into LINQ with three chapters dedicated to the topic
  • Explore concurrency and asynchrony, advanced threading, and parallel programming
  • Work with .NET features, including regular expressions, networking, spans, reflection, and cryptography

About the Author:

Book Details:

  • ASIN: B08XN578HZ
  • Publisher: O’Reilly Media; 1st edition (February 26, 2021)
  • Publication date: February 26, 2021
  • Language: English
  • Print length: 1884 pages

Table of Contents:


Fair Use Sources:

C Language C# .NET C++ Cloud Data Science - Big Data DevOps Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript

Integrated Development Environment (IDE)

“An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of at least a source code editorbuild automation tools and a debugger. Some IDEs, such as Visual Studio, NetBeans and Eclipse, contain the necessary compilerinterpreter, or both; others, such as SharpDevelop and Lazarus, do not.” (WP)

“The boundary between an IDE and other parts of the broader software development environment is not well-defined; sometimes a version control system or various tools to simplify the construction of a graphical user interface (GUI) are integrated. Many modern IDEs also have a class browser, an object browser, and a class hierarchy diagram for use in object-oriented software development.” (WP)

Software Engineering

Microsoft ASP.NET

“ASP.NET is a unified web development model integrated with .NET framework, designed to provide services to create dynamic web applications and web services. It is built on the Common Language Runtime (CLR) of the .NET framework and includes those benefits like multi-language interoperability, type safety, garbage collection and inheritance.” (TcPd)

“Mark Anders and Scott Guthrie of Microsoft created the first version of ASP.NET in 1992. It was created to facilitate the development of distributed applications in structured and object-oriented manner by separating the presentation and content and hence write clean code. ASP.NET uses the code-behind model to generate dynamic pages based on Model-View-Controller architecture.” (TcPd)

“They have some the major differences from ASP, an earlier version of ASP.NET. The object model of ASP.NET has thus significantly improved from ASP, which makes it fully backward compatible to ASP.” (TcPd)

“These differences include:
1. Usage of compiled code (instead of interpreted code),
2. Event-driven server-side scripting model,
3. State management,
4. Rapid application development using controls and libraries of the .NET framework.
5. Dynamic programming code is placed separately in a file or specially designated tag. This avoids the program code getting modified during runtime.” (TcPd)

“ASP.NET works with the Internet Information Server (IIS) to deliver the content in response to client requests. While processing the requests, ASP.NET provides access to all .NET classes, custom components and databases, similar to that of a desktop application.” (TcPd)

“Web forms are the building blocks of application development in ASP.NET. They provide lot of flexibility by allowing controls to be used on a page as objects. These controls can handle events such as Load, Click and Change, similar to those in desktop applications. Other than Web forms, ASP.NET can be used to create XML Web services that can allow building modular, distributed web applications, written in any language. These services are interoperable across variety of platforms and devices.” (TcPd)

“In addtion, ASP.NET implements state management by sending the information (viewstate) related to state of controls on a web form to the server in a postback request. It provides side-by-side execution applications of multiple denominations allowing them to be installed on the same system with different versions of .NET frameworks. Furthermore, it uses XML support for data storage, configuration and manipulation. However, when it comes to securing its applications, ASP.NET uses the code access security and role based security features of .NET framework and inherent methods of IIS for authenticating user credentials.” (TcPd)

Fair Use Source: TcPd


Fair Use Sources:

C# .NET Software Engineering

C# 9.0 Pocket Reference: Instant Help for C# 9.0 Programmers, 1st Edition

See also: C# and .NET Framework, C# Bibliography and C# 9.0 in a Nutshell

C# 9.0 Pocket Reference: Instant Help for C# 9.0 Programmers 1st Edition, by Joseph Albahari and Ben Albahari, 2021, B08SYWWDTX (CS9PR)

Fair Use Source: B08SYWWDTX (CS9PR)

When you have questions about C# 9.0 or .NET 5, this best-selling guide has the answers you need. C# is a language of unusual flexibility and breadth, but with its continual growth there’s so much more to learn. In the tradition of O’Reilly’s Nutshell guides, this thoroughly updated edition is simply the best one-volume reference to the C# language available today.

Organized around concepts and use cases, C# 9.0 in a Nutshell provides intermediate and advanced programmers with a concise map of C# and .NET that also plumbs significant depths.

  • Get up to speed on C#, from syntax and variables to advanced topics such as pointers, records, closures, and patterns
  • Dig deep into LINQ with three chapters dedicated to the topic
  • Explore concurrency and asynchrony, advanced threading, and parallel programming
  • Work with .NET features, including regular expressions, networking, spans, reflection, and cryptography

Joseph Albahari is author of C# 8.0 in a NutshellC# 8.0 Pocket Reference, and LINQ Pocket Reference (all from O’Reilly). He also wrote LINQPad, the popular code scratchpad and LINQ querying utility.

Book Details

  • Publisher: O’Reilly Media; 1st edition (January 13, 2021)
  • Publication date: January 13, 2021
  • Print length: 362 pages

Table of Contents:

A First C# Program Compilation

Syntax Identifiers and Keywords

Literals, Punctuators, and Operators


Type Basics Predefined Type Examples

Custom Type Examples

Types and Conversions

Value Types Versus Reference Types

Predefined Type Taxonomy

Numeric Types Numeric Literals

Numeric Conversions

Arithmetic Operators

Increment and Decrement Operators

Specialized Integral Operations

8- and 16-Bit Integral Types

Special Float and Double Values

double Versus decimal

Real Number Rounding Errors

Boolean Type and Operators Equality and Comparison Operators

Conditional Operators

Strings and Characters String Type

Arrays Default Element Initialization

Indices and Ranges

Multidimensional Arrays

Simplified Array Initialization Expressions

Variables and Parameters The Stack and the Heap

Definite Assignment

Default Values


var — Implicitly Typed Local Variables

Target-Typed new Expressions (C# 9)

Expressions and Operators Assignment Expressions

Operator Precedence and Associativity

Operator Table

Null Operators Null-Coalescing Operator

Null-Coalescing Assignment Operator

Null-Conditional Operator

Statements Declaration Statements

Expression Statements

Selection Statements

Iteration Statements

Jump Statements

Namespaces The using Directive

using static

Rules Within a Namespace

Aliasing Types and Namespaces

Classes Fields



Instance Constructors


Object Initializers

The this Reference



Static Constructors

Static Classes


Partial Types and Methods

The nameof Operator

Inheritance Polymorphism

Casting and Reference Conversions

Virtual Function Members

Abstract Classes and Abstract Members

Hiding Inherited Members

Sealing Functions and Classes

The base Keyword

Constructors and Inheritance

Overloading and Resolution

The object Type Boxing and Unboxing

Static and Runtime Type Checking

The GetType Method and typeof Operator

Object Member Listing

Equals, ReferenceEquals, and GetHashCode

The ToString Method

Structs Struct Construction Semantics

readonly Structs and Functions

Access Modifiers Friend Assemblies

Accessibility Capping

Interfaces Extending an Interface

Explicit Interface Implementation

Implementing Interface Members Virtually

Reimplementing an Interface in a Subclass

Default Interface Members

Enums Enum Conversions

Flags Enums

Enum Operators

Nested Types

Generics Generic Types

Generic Methods

Declaring Type Parameters

typeof and Unbound Generic Types

The default Generic Value

Generic Constraints

Subclassing Generic Types

Self-Referencing Generic Declarations

Static Data



Delegates Writing Plug-In Methods with Delegates

Instance and Static Method Targets

Multicast Delegates

Generic Delegate Types

The Func and Action Delegates

Delegate Compatibility

Events Standard Event Pattern

Event Accessors

Lambda Expressions Capturing Outer Variables

Lambda Expressions Versus Local Methods

Anonymous Methods

try Statements and Exceptions The catch Clause

The finally Block

Throwing Exceptions

Key Properties of System.Exception

Enumeration and Iterators Enumeration

Collection Initializers


Iterator Semantics

Composing Sequences

Nullable Value Types Nullable Struct

Nullable Conversions

Boxing/Unboxing Nullable Values

Operator Lifting

bool? with & and | Operators

Nullable Types and Null Operators

Nullable Reference Types

Extension Methods Extension Method Chaining

Ambiguity and Resolution

Anonymous Types

Tuples Naming Tuple Elements

Deconstructing Tuples

Records (C# 9) Defining a Record

Nondestructive Mutation

Primary Constructors

Records and Equality Comparison

Patterns var Pattern

Constant Pattern

Relational Patterns (C# 9)

Pattern Combinators (C# 9)

Tuple and Positional Patterns

Property Patterns

LINQ LINQ Fundamentals

Deferred Execution

Standard Query Operators

Chaining Query Operators

Query Expressions

The let Keyword

Query Continuations

Multiple Generators




OfType and Cast

Dynamic Binding Static Binding Versus Dynamic Binding

Custom Binding

Language Binding


Runtime Representation of dynamic

Dynamic Conversions

var Versus dynamic

Dynamic Expressions

Dynamic Member Overload Resolution

Uncallable Functions

Operator Overloading Operator Functions

Overloading Equality and Comparison Operators

Custom Implicit and Explicit Conversions

Attributes Attribute Classes

Named and Positional Attribute Parameters

Attribute Targets

Specifying Multiple Attributes

Writing Custom Attributes

Retrieving Attributes at Runtime

Caller Info Attributes

Asynchronous Functions The await and async Keywords

Capturing Local State

Writing Asynchronous Functions


Asynchronous Lambda Expressions

Asynchronous Streams

Unsafe Code and Pointers Pointer Basics

Unsafe Code

The fixed Statement

The Pointer-to-Member Operator

The stackalloc Keyword

Fixed-Size Buffers


Function Pointers (C# 9)

Preprocessor Directives Pragma Warning

XML Documentation Standard XML Documentation Tags



Fair Use Source: B08SYWWDTX (CS9PR)

Bibliography C# .NET Software Engineering

Essential C# 8.0 by Mark Michaelis

See also: C# and .NET Framework, C# Bibliography

Essential C# 8.0 by Mark Michaelis, 2020, B08Q84TH84 (EC8MM)

Fair Use Source: B08Q84TH84 (EC8MM)

The Comprehensive, Expert Guide to C# 8.0 for Programmers at All Levels
“Welcome to one of the most venerable and trusted franchises you could dream of in the world of C# books—and probably far beyond! . . . Mark is super smart, insists on understanding everything to the core, and has phenomenal insight into how things affect real developers. . . . He goes right to the essence and communicates with great integrity—no sugarcoating—and has a keen eye for practical value and real-world problems.”
— From the Foreword by Mads Torgersen, C# Lead Designer, Microsoft
Essential C# 8.0 is a well-organized, no-fluff guide to C# 8.0 for programmers at all levels of experience. This edition retains all the valuable content of prior editions and adds discussions of null reference types, indices and ranges, enhanced pattern matching, asynchronous stream, and more.

World-class C# expert Mark Michaelis presents a comprehensive tutorial and reference for the entire language, providing an accelerated learning opportunity to achieve expert C# programming skills. He includes key C# 8.0 enhancements, succinct examples to illustrate central constructs, and updated coding guidelines for minimizing bugs and writing code that’s easier to evolve. To help you quickly fi nd what you need, there are version-specific indexes of C# 6.0, 7.0, and 8.0 topics and visual icons that identify when each language innovation was introduced.

  • Use structured programming constructs to write functioning code immediately
  • Learn both the complexities and solutions to nullable reference types
  • Thoroughly master C# object constructs, including classes, inheritance, and interfaces
  • Reduce code redundancy with generics, delegates, lambda expressions, and events
  • Take full advantage of collections, including the new standard query operator collection API
  • Make the most of reflection, attributes, and the declarative programming paradigm
  • Improve multithreading with the task-based async pattern and C# 8.0 asynchronous streams
  • Enhance performance through the parallel processing of data and multithreading tasks
  • Program complex types with enhanced pattern matching syntax
  • Interoperate with unmanaged code written in other languages, including C-based APIs
  • Explore the relationship between C# programs and the underlying CLI runtime


Mark Michaelis ( is the founder of IntelliTect and serves as the Chief Technical Architect and Trainer. A premier authority in Microsoft development technologies with recognized coding expertise and proven training methods, IntelliTect’s CEO delivers customized strategic technology consulting to CIOs, technology executives, and industry leaders. Recognized by Microsoft as a Regional Director since 2007 and distinguished Microsoft MVP for C# and Visual Studio Team System since 1996, this CEO has honed his engineering skills by serving on several Microsoft software design review teams, including C#, Azure and Visual Studio Team System ALM.

Book Details

  • ASIN: B08Q84TH84
  • Publisher: Addison-Wesley Professional; 7th edition (October 14, 2020)
  • Publication date: October 14, 2020
  • Print length: 2350 pages


“Throughout the history of software engineering, the methodology used to write computer programs has undergone several paradigm shifts, each building on the foundation of the former by increasing code organization and decreasing complexity. This book takes you through these same paradigm shifts.

The beginning chapters take you through sequential programming structure in which statements are executed in the order in which they are written. The problem with this model is that complexity increases exponentially as the requirements increase. To reduce this complexity, code blocks are moved into methods, creating a structured programming model. This allows you to call the same code block from multiple locations within a program, without duplicating code. Even with this construct, however, programs quickly become unwieldy and require further abstraction. Object-oriented programming, introduced in Chapter 6, was the response. In subsequent chapters, you will learn about additional methodologies, such as interface-based programming, LINQ (and the transformation it makes to the collection API), and eventually rudimentary forms of declarative programming (in Chapter 18) via attributes.

This book has three main functions.

It provides comprehensive coverage of the C# language, going beyond a tutorial and offering a foundation upon which you can begin effective software development projects.

For readers already familiar with C#, this book provides insight into some of the more complex programming paradigms and provides in-depth coverage of the features introduced in the latest version of the language, C# 7.0 and .NET Framework 4.7/.NET Core 2.0.

It serves as a timeless reference even after you gain proficiency with the language.

The key to successfully learning C# is to start coding as soon as possible. Don’t wait until you are an “expert” in theory; start writing software immediately. As a believer in iterative development, I hope this book enables even a novice programmer to begin writing basic C# code by the end of Chapter 2.

Many topics are not covered in this book. You won’t find coverage of topics such as ASP.NET, ADO.NET, Xamarin, smart client development, distributed programming, and so on. Although these topics are relevant to .NET, to do them justice requires books of their own. Fortunately, Addison-Wesley’s Microsoft Windows Development Series provides a wealth of writing on these topics. Essential C# 7.0 focuses on C# and the types within the Base Class Library. Reading this book will prepare you to focus on and develop expertise in any of the areas covered by the rest of the series.

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, 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 answers to 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 7.0, some of the most prominent enhancements are

– String interpolation (see Chapter 2)

– Implicitly typed variables (see Chapter 3)

– Tuples (see Chapter 3)

– Pattern matching (see Chapter 4)

– Extension methods (see Chapter 6)

– Partial methods (see Chapter 6)

– 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 19)

– Parallel query processing with PLINQ (Chapter 19)

– Concurrent collections (Chapter 20)

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

Features of This Book

Essential C# 7.0 is a language book that adheres to the core C# Language 7.0 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.

C# Coding Guidelines

One of the more significant enhancements included in Essential C# 7.0 is C# coding guidelines, as shown in the following example taken from Chapter 17:


DO ensure that equal objects have equal hash codes.

DO ensure that the hash code of an object never changes while it is in a hash table.

DO ensure that the hashing algorithm quickly produces a well-distributed hash.

DO ensure that the hashing algorithm is robust in any possible object state.

These guidelines are the key to differentiating a programmer who knows the syntax from an expert who can discern the most effective code to write based on the circumstances. Such an expert not only gets the code to compile but does so while following best practices that minimize bugs and enable maintenance well into the future. The coding guidelines highlight some of the key principles that readers will want to be sure to incorporate into their development.

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, or 7.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

Click here to view code image

class Comment Samples { static void Main() { string firstName; //Variable for storing the first name string lastName; //Variable for storing the last name System.Console.WriteLine(“Hey you!”); System.Console.Write /* No new line / ( “Enter your first name: “); firstName = System.Console.ReadLine(); System.Console.Write / No new line / ( “Enter your last name: “); lastName = System.Console.ReadLine(); / Display a greeting to the console using composite formatting. */ System.Console.WriteLine(“Your full name is {0} {1}.”, firstName, lastName); // This is the end // of the program listing } }

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( “Your full name is {0} {1}.”, firstName, lastName);

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.


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

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.

Helpful Notes

Depending on your level of experience, special features will help you navigate through the text.

Beginner Topics provide definitions or explanations targeted specifically toward entry-level programmers.

Advanced Topics enable experienced developers to focus on the material that is most relevant to them.

Callout notes highlight key principles in callout boxes so that readers easily recognize their significance.

Language Contrast sidebars identify key differences between C# and its predecessors to aid those familiar with other languages.

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# 7.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 a chapter 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# 6.0–7.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 the nullable modifier and a C# 7.0-introduced feature, tuples. 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.

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.

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 is 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 new 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 new Enumerable class. This class makes available an entirely new collection API known as the standard query operators and 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—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 discusses how to work with threads and provides best practices to avoid the problems that plague multithreaded applications.

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

Chapter 21—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 22—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# 5.0, 6.0, and 7.0 Topics: These indexes provide quick references for the features added in C# 4.0 through 7.0. They are specifically designed to help programmers quickly update their language skills to a more recent version.” (EC8MM)


Fair Use Source: B08Q84TH84 (EC8MM)