C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development - Fourth Edition: Build applications with C#, .NET Core, Entity Framework Core, ASP.NET Core, and ML.NET using Visual Studio Code, 4th Edition

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development

Fourth Edition

Build applications with C#, .NET Core, Entity Framework Core, ASP.NET Core, and ML.NET using Visual Studio Code

Mark J. Price

BIRMINGHAM - MUMBAI

C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development

Fourth Edition

Copyright © 2019 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Acquisition Editor: Ben Renow-Clarke

Acquisition Editor – Peer Reviews: Suresh Jain

Content Development Editor: Ian Hough

Project Editor: Radhika Atitkar

Technical Editor: Aniket Shetty

Proofreader: Safis Editing

Indexer: Rekha Nair

Presentation Designer: Sandip Tadge

First published: March 2016

Second edition: March 2017

Third edition: November 2017

Fourth edition: October 2019

Production reference: 3311219

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-78847-812-0

www.packt.com

packt.com

Subscribe to our online digital library for full access to over 7,000 books and videos, as well as industry leading tools to help you plan your personal development and advance your career. For more information, please visit our website.

Why subscribe?

Spend less time learning and more time coding with practical eBooks and Videos from over 4,000 industry professionals

Learn better with Skill Plans built especially for you

Get a free eBook or video every month

Fully searchable for easy access to vital information

Copy and paste, print, and bookmark content

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.Packt.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.

At www.Packt.com, you can also read a collection of free technical articles, sign up for a range of free newsletters, and receive exclusive discounts and offers on Packt books and eBooks.

Contributors

About the author

Mark J. Price is a Microsoft Specialist: Programming in C# and Architecting Microsoft Azure Solutions, with more than 20 years of educational and programming experience.

Since 1993, Mark has passed more than 80 Microsoft programming exams and specializes in preparing others to pass them too. His students range from professionals with decades of experience to 16-year-old apprentices with none. He successfully guides all of them by combining educational skills with real-world experience in consulting and developing systems for enterprises worldwide.

Between 2001 and 2003, Mark was employed full-time to write official courseware for Microsoft in Redmond, USA. His team wrote the first training courses for C# while it was still an early alpha version. While with Microsoft, he taught train-the-trainer classes to get Microsoft Certified Trainers up to speed on C# and .NET.

Currently, Mark creates and delivers training courses for Episerver's Digital Experience Platform, the best .NET CMS for Digital Marketing and E-commerce.

In 2010, Mark studied for a Postgraduate Certificate in Education (PGCE). He taught GCSE and A-Level mathematics in two London secondary schools. He holds a Computer Science BSc. Hons. degree from the University of Bristol, UK.

Thank you to my parents, Pamela and Ian, for raising me to be polite, hardworking, and curious about the world. Thank you to my sisters, Emily and Juliet, for loving me despite being their awkward older brother. Thank you to my friends and colleagues who inspire me technically and creatively. Lastly, thanks to all the students I have taught over the years for motivating me to be the best teacher that I can be.

About the reviewer

Damir Arh has many years of experience with software development and maintenance; from complex enterprise software projects to modern consumer oriented mobile applications. Although he has worked with a wide spectrum of different languages, his favorite language remains C#. In his drive towards better development processes, he is a proponent of test-driven development, continuous integration, and continuous deployment. He shares his knowledge by speaking at local user groups and conferences, blogging, and writing articles. He has received the prestigious Microsoft MVP award for developer technologies 7 times in a row. In his spare time, he's always on the move: hiking, geocaching, running, and rock climbing.

I'd like to thank my family and friends for their patience and understanding during the weekends and evenings I spent on my computer to help make this book better for everyone.

Contents

Hello, C#! Welcome, .NET!

Setting up your development environment

Using Visual Studio Code for cross-platform development

Using Visual Studio 2019 for Windows app development

Using Visual Studio for Mac for mobile development

Recommended tools for chapters

Deploying cross-platform

Understanding Microsoft Visual Studio Code versions

Downloading and installing Visual Studio Code

Installing other extensions

Understanding .NET

Understanding the .NET Framework

Understanding the Mono and Xamarin projects

Understanding .NET Core

Understanding future versions of .NET

Understanding .NET Core support

What is different about .NET Core?

Understanding .NET Standard

.NET platforms and tools used by the book editions

Understanding intermediate language

Understanding .NET Native

Comparing .NET technologies

Building console apps using Visual Studio Code

Writing code using Visual Studio Code

Compiling and running code using dotnet CLI

Downloading solution code from a GitHub repository

Using Git with Visual Studio Code

Cloning the book solution code repository

Looking for help

Reading Microsoft documentation

Getting help for the dotnet tool

Getting definitions of types and their members

Looking for answers on Stack Overflow

Searching for answers using Google

Subscribing to the official .NET blog

Practicing and exploring

Exercise 1.1 – Test your knowledge

Exercise 1.2 – Practice C# anywhere

Exercise 1.3 – Explore topics

Summary

Speaking C#

Introducing C#

Understanding language versions and features

C# 1.0

C# 2.0

C# 3.0

C# 4.0

C# 5.0

C# 6.0

C# 7.0

C# 7.1

C# 7.2

C# 7.3

C# 8.0

Discovering your C# compiler versions

Enabling a specific language version compiler

Understanding C# basics

Understanding C# grammar

Statements

Comments

Blocks

Understanding C# vocabulary

Help for writing correct code

Verbs are methods

Nouns are types, fields, and variables

Revealing the extent of the C# vocabulary

Working with variables

Naming things and assigning values

Literal values

Storing text

Understanding verbatim strings

Storing numbers

Storing whole numbers

Storing real numbers

Writing code to explore number sizes

Comparing double and decimal types

Storing Booleans

Using Visual Studio Code workspaces

Storing any type of object

Storing dynamic types

Declaring local variables

Specifying and inferring the type of a local variable

Getting default values for types

Storing multiple values

Working with null values

Making a value type nullable

Understanding nullable reference types

Enabling nullable and non-nullable reference types

Declaring non-nullable variables and parameters

Checking for null

Exploring console applications further

Displaying output to the user

Formatting using numbered positional arguments

Formatting using interpolated strings

Understanding format strings

Getting text input from the user

Importing a namespace

Simplifying the usage of the console

Getting key input from the user

Getting arguments

Setting options with arguments

Handling platforms that do not support an API

Practicing and exploring

Exercise 2.1 – Test your knowledge

Exercise 2.2 – Practice number sizes and ranges

Exercise 2.3 – Explore topics

Summary

Controlling Flow and Converting Types

Operating on variables

Unary operators

Binary arithmetic operators

Assignment operators

Logical operators

Conditional logical operators

Bitwise and binary shift operators

Miscellaneous operators

Understanding selection statements

Branching with the if statement

Why you should always use braces with if statements

Pattern matching with the if statement

Branching with the switch statement

Pattern matching with the switch statement

Simplifying switch statements with switch expressions

Understanding iteration statements

Looping with the while statement

Looping with the do statement

Looping with the for statement

Looping with the foreach statement

Understanding how foreach works internally

Casting and converting between types

Casting numbers implicitly and explicitly

Converting with the System.Convert type

Rounding numbers

Understanding the default rounding rules

Taking control of rounding rules

Converting from any type to a string

Converting from a binary object to a string

Parsing from strings to numbers or dates and times

Avoiding exceptions using the TryParse method

Handling exceptions when converting types

Wrapping error-prone code in a try block

Catching all exceptions

Catching specific exceptions

Checking for overflow

Throwing overflow exceptions with the checked statement

Disabling compiler overflow checks with the unchecked statement

Practicing and exploring

Exercise 3.1 – Test your knowledge

Exercise 3.2 – Explore loops and overflow

Exercise 3.3 – Practice loops and operators

Exercise 3.4 – Practice exception handling

Exercise 3.5 – Test your knowledge of operators

Exercise 3.6 – Explore topics

Summary

Writing, Debugging, and Testing Functions

Writing functions

Writing a times table function

Writing a function that returns a value

Writing mathematical functions

Converting numbers from ordinal to cardinal

Calculating factorials with recursion

Documenting functions with XML comments

Debugging during development

Creating code with a deliberate bug

Setting a breakpoint

Navigating with the debugging toolbar

Debugging windows

Stepping through code

Customizing breakpoints

Logging during development and runtime

Instrumenting with Debug and Trace

Writing to the default trace listener

Configuring trace listeners

Switching trace levels

Unit testing functions

Creating a class library that needs testing

Writing unit tests

Running unit tests

Practicing and exploring

Exercise 4.1 – Test your knowledge

Exercise 4.2 – Practice writing functions with debugging and unit testing

Exercise 4.3 – Explore topics

Summary

Building Your Own Types with Object-Oriented Programming

Talking about object-oriented programming

Building class libraries

Creating a class library

Defining a class

Understanding members

Instantiating a class

Referencing an assembly

Importing a namespace to use a type

Managing multiple files

Understanding objects

Inheriting from System.Object

Storing data within fields

Defining fields

Understanding access modifiers

Setting and outputting field values

Storing a value using an enum type

Storing multiple values using an enum type

Storing multiple values using collections

Making a field static

Making a field constant

Making a field read-only

Initializing fields with constructors

Setting fields with default literals

Writing and calling methods

Returning values from methods

Combining multiple returned values using tuples

Naming the fields of a tuple

Inferring tuple names

Deconstructing tuples

Defining and passing parameters to methods

Overloading methods

Passing optional parameters and naming arguments

Controlling how parameters are passed

Splitting classes using partial

Controlling access with properties and indexers

Defining readonly properties

Defining settable properties

Defining indexers

Practicing and exploring

Exercise 5.1 – Test your knowledge

Exercise 5.2 – Explore topics

Summary

Implementing Interfaces and Inheriting Classes

Setting up a class library and console application

Simplifying methods

Implementing functionality using methods

Implementing functionality using operators

Implementing functionality using local functions

Raising and handling events

Calling methods using delegates

Defining and handling delegates

Defining and handling events

Implementing interfaces

Common interfaces

Comparing objects when sorting

Comparing objects using a separate class

Defining interfaces with default implementations

Making types safely reusable with generics

Working with generic types

Working with generic methods

Managing memory with reference and value types

Working with struct types

Releasing unmanaged resources

Ensuring that Dispose is called

Inheriting from classes

Extending classes

Hiding members

Overriding members

Preventing inheritance and overriding

Understanding polymorphism

Casting within inheritance hierarchies

Implicit casting

Explicit casting

Avoiding casting exceptions

Inheriting and extending .NET types

Inheriting exceptions

Extending types when you can't inherit

Using static methods to reuse functionality

Using extension methods to reuse functionality

Practicing and exploring

Exercise 6.1 – Test your knowledge

Exercise 6.2 – Practice creating an inheritance hierarchy

Exercise 6.3 – Explore topics

Summary

Understanding and Packaging .NET Types

Introducing .NET Core 3.0

.NET Core 1.0

.NET Core 1.1

.NET Core 2.0

.NET Core 2.1

.NET Core 2.2

.NET Core 3.0

Understanding .NET Core components

Understanding assemblies, packages, and namespaces

Understanding dependent assemblies

Understanding the Microsoft .NET Core App platform

Understanding NuGet packages

Understanding frameworks

Importing a namespace to use a type

Relating C# keywords to .NET types

Sharing code cross-platform with .NET Standard class libraries

Publishing your applications for deployment

Creating a console application to publish

Understanding dotnet commands

Creating new projects

Managing projects

Publishing a self-contained app

Decompiling assemblies

Packaging your libraries for NuGet distribution

Referencing a NuGet package

Fixing dependencies

Packaging a library for NuGet

Testing your package

Porting from .NET Framework to .NET Core

Could you port?

Should you port?

Differences between .NET Framework and .NET Core

Understanding the .NET Portability Analyzer

Using non-.NET Standard libraries

Practicing and exploring

Exercise 7.1 – Test your knowledge

Exercise 7.2 – Explore topics

Summary

Working with Common .NET Types

Working with numbers

Working with big integers

Working with complex numbers

Working with text

Getting the length of a string

Getting the characters of a string

Splitting a string

Getting part of a string

Checking a string for content

Joining, formatting, and other string members

Building strings efficiently

Pattern matching with regular expressions

Checking for digits entered as text

Understanding the syntax of a regular expression

Examples of regular expressions

Splitting a complex comma-separated string

Storing multiple objects in collections

Common features of all collections

Understanding collection choices

Lists

Dictionaries

Stacks

Queues

Sets

Working with lists

Working with dictionaries

Sorting collections

Using specialized collections

Using immutable collections

Working with spans, indexes, and ranges

Using memory efficiently using spans

Identifying positions with the Index type

Identifying ranges with the Range type

Using indexes and ranges

Working with network resources

Working with URIs, DNS, and IP addresses

Pinging a server

Working with types and attributes

Versioning of assemblies

Reading assembly metadata

Creating custom attributes

Doing more with reflection

Internationalizing your code

Practicing and exploring

Exercise 8.1 – Test your knowledge

Exercise 8.2 – Practice regular expressions

Exercise 8.3 – Practice writing extension methods

Exercise 8.4 – Explore topics

Summary

Working with Files, Streams, and Serialization

Managing the filesystem

Handling cross-platform environments and filesystems

Managing drives

Managing directories

Managing files

Managing paths

Getting file information

Controlling how you work with files

Reading and writing with streams

Writing to text streams

Writing to XML streams

Disposing of file resources

Compressing streams

Compressing with the Brotli algorithm

High-performance streams using pipelines

Asynchronous streams

Encoding and decoding text

Encoding strings as byte arrays

Encoding and decoding text in files

Serializing object graphs

Serializing as XML

Generating compact XML

Deserializing XML files

Serializing with JSON

High-performance JSON processing

Practicing and exploring

Exercise 9.1 – Test your knowledge

Exercise 9.2 – Practice serializing as XML

Exercise 9.3 – Explore topics

Summary

Protecting Your Data and Applications

Understanding the vocabulary of protection

Keys and key sizes

IVs and block sizes

Salts

Generating keys and IVs

Encrypting and decrypting data

Encrypting symmetrically with AES

Hashing data

Hashing with the commonly used SHA256

Signing data

Signing with SHA256 and RSA

Generating random numbers

Generating random numbers for games

Generating random numbers for cryptography

What's new in cryptography

Authenticating and authorizing users

Implementing authentication and authorization

Protecting application functionality

Practicing and exploring

Exercise 10.1 – Test your knowledge

Exercise 10.2 – Practice protecting data with encryption and hashing

Exercise 10.3 – Practice protecting data with decryption

Exercise 10.4 – Explore topics

Summary

Working with Databases Using Entity Framework Core

Understanding modern databases

Understanding Entity Framework

Using a sample relational database

Setting up SQLite for macOS

Setting up SQLite for Windows

Creating the Northwind sample database for SQLite

Managing the Northwind sample database with SQLiteStudio

Setting up EF Core

Choosing an EF Core data provider

Connecting to the database

Defining EF Core models

EF Core conventions

EF Core annotation attributes

EF Core Fluent API

Understanding data seeding

Building an EF Core model

Defining the Category and Product entity classes

Defining the Northwind database context class

Querying EF Core models

Filtering and sorting products

Logging EF Core

Logging with query tags

Pattern matching with Like

Defining global filters

Loading patterns with EF Core

Eager loading entities

Enabling lazy loading

Explicit loading entities

Manipulating data with EF Core

Inserting entities

Updating entities

Deleting entities

Pooling database contexts

Transactions

Defining an explicit transaction

Practicing and exploring

Exercise 11.1 – Test your knowledge

Exercise 11.2 – Practice exporting data using different serialization formats

Exercise 11.3 – Explore the EF Core documentation

Summary

Querying and Manipulating Data Using LINQ

Writing LINQ queries

Extending sequences with the Enumerable class

Filtering entities with Where

Targeting a named method

Simplifying the code by removing the explicit delegate instantiation

Targeting a lambda expression

Sorting entities

Sorting by a single property using OrderBy

Sorting by a subsequent property using ThenBy

Filtering by type

Working with sets and bags using LINQ

Using LINQ with EF Core

Building an EF Core model

Filtering and sorting sequences

Projecting sequences into new types

Joining and grouping sequences

Aggregating sequences

Sweetening LINQ syntax with syntactic sugar

Using multiple threads with parallel LINQ

Creating an app that benefits from multiple threads

Using Windows 10

Using macOS

For all operating systems

Creating your own LINQ extension methods

Working with LINQ to XML

Generating XML using LINQ to XML

Reading XML using LINQ to XML

Practicing and exploring

Exercise 12.1 – Test your knowledge

Exercise 12.2 – Practice querying with LINQ

Exercise 12.3 – Explore topics

Summary

Improving Performance and Scalability Using Multitasking

Understanding processes, threads, and tasks

Monitoring performance and resource usage

Evaluating the efficiency of types

Monitoring performance and memory use

Implementing the Recorder class

Measuring the efficiency of processing strings

Running tasks asynchronously

Running multiple actions synchronously

Running multiple actions asynchronously using tasks

Waiting for tasks

Continuing with another task

Nested and child tasks

Synchronizing access to shared resources

Accessing a resource from multiple threads

Applying a mutually exclusive lock to a resource

Understanding the lock statement and avoiding deadlocks

Making CPU operations atomic

Applying other types of synchronization

Understanding async and await

Improving responsiveness for console apps

Improving responsiveness for GUI apps

Improving scalability for web applications and web services

Common types that support multitasking

Using await in catch blocks

Working with async streams

Practicing and exploring

Exercise 13.1 – Test your knowledge

Exercise 13.2 – Explore topics

Summary

Practical Applications of C# and .NET

Understanding app models for C# and .NET

Building websites using ASP.NET Core

Building websites using a web content management system

Understanding web applications

Building and consuming web services

Building intelligent apps

New features for ASP.NET Core

ASP.NET Core 1.0

ASP.NET Core 1.1

ASP.NET Core 2.0

ASP.NET Core 2.1

ASP.NET Core 2.2

ASP.NET Core 3.0

Understanding SignalR

Understanding Blazor

JavaScript and friends

Silverlight – C# and .NET using a plugin

WebAssembly – a target for Blazor

Blazor on the server-side or client-side

Understanding the bonus chapters

Building Windows desktop apps

Building cross-platform mobile apps

Building an entity data model for Northwind

Creating a class library for Northwind entity models

Creating a class library for a Northwind database context

Summary

Building Websites Using ASP.NET Core Razor Pages

Understanding web development

Understanding HTTP

Client-side web development

Understanding ASP.NET Core

Classic ASP.NET versus modern ASP.NET Core

Creating an ASP.NET Core project

Testing and securing the website

Enabling static and default files

Exploring Razor Pages

Enabling Razor Pages

Defining a Razor Page

Using shared layouts with Razor Pages

Using code-behind files with Razor Pages

Using Entity Framework Core with ASP.NET Core

Configure Entity Framework Core as a service

Manipulating data using Razor pages

Enabling a model to insert entities

Defining a form to insert new suppliers

Using Razor class libraries

Using a Razor class library

Practicing and exploring

Exercise 15.1 – Test your knowledge

Exercise 15.2 – Practice building a data-driven web page

Exercise 15.3 – Explore topics

Summary

Building Websites Using the Model-View-Controller Pattern

Setting up an ASP.NET Core MVC website

Creating and exploring an ASP.NET Core MVC website

Reviewing the ASP.NET Core MVC website

Reviewing the ASP.NET Core Identity database

Exploring an ASP.NET Core MVC website

Understanding ASP.NET Core MVC startup

Understanding the default MVC route

Understanding controllers and actions

Understanding filters

Using a filter to secure an action method

Using a filter to cache a response

Using a filter to define a custom route

Understanding entity and view models

Understanding views

Customizing an ASP.NET Core MVC website

Defining a custom style

Setting up the category images

Understanding Razor syntax

Defining a typed view

Testing the customized home page

Passing parameters using a route value

Understanding model binders

Validating the model

Understanding view helper methods

Querying a database and using display templates

Improving scalability using asynchronous tasks

Making controller action methods asynchronous

Using other project templates

Installing additional template packs

Practicing and exploring

Exercise 16.1 – Test your knowledge

Exercise 16.2 – Practice implementing MVC by implementing a category detail page

Exercise 16.3 – Practice improving scalability by understanding and implementing async action methods

Exercise 16.4 – Explore topics

Summary

Building Websites Using a Content Management System

Understanding the benefits of a CMS

Understanding basic CMS features

Understanding enterprise CMS features

Understanding CMS platforms

Understanding Piranha CMS

Creating and exploring a Piranha CMS website

Editing site and page content

Creating a new top-level page

Creating a new child page

Reviewing the blog archive

Exploring authentication and authorization

Exploring configuration

Testing the new content

Understanding routing

Understanding media

Understanding the application service

Understanding content types

Understanding component types

Understanding standard fields

Reviewing some content types

Understanding standard blocks

Reviewing component types and standard blocks

Defining components, content types, and templates

Reviewing the standard page type

Reviewing the blog archive page type

Defining custom content and component types

Creating custom regions

Creating an entity data model

Creating custom page types

Creating custom view models

Defining custom content templates for content types

Configuring start up and importing from a database

Testing the Northwind CMS website

Uploading images and creating the catalog root

Importing category and product content

Managing catalog content

Reviewing how Piranha stores content

Practicing and exploring

Exercise 17.1 – Test your knowledge

Exercise 17.2 – Practice defining a block type for rendering YouTube videos

Exercise 17.3 – Explore topics

Summary

Building and Consuming Web Services

Building web services using ASP.NET Core Web API

Understanding web service acronyms

Creating an ASP.NET Core Web API project

Reviewing the web service's functionality

Creating a web service for the Northwind database

Creating data repositories for entities

Implementing a Web API controller

Configuring the customers repository and Web API controller

Specifying problem details

Documenting and testing web services

Testing GET requests using a browser

Testing HTTP requests with REST Client extension

Enabling Swagger

Testing requests with Swagger UI

Consuming services using HTTP clients

Understanding HttpClient

Configuring HTTP clients using HttpClientFactory

Enabling Cross-Origin Resource Sharing

Implementing advanced features

Implementing Health Check API

Implementing Open API analyzers and conventions

Understanding endpoint routing

Configuring endpoint routing

Understanding other communication technologies

Understanding Windows Communication Foundation (WCF)

Understanding gRPC

Practicing and exploring

Exercise 18.1 – Test your knowledge

Exercise 18.2 – Practice creating and deleting customers with HttpClient

Exercise 18.3 – Explore topics

Summary

Building Intelligent Apps Using Machine Learning

Understanding machine learning

Understanding the machine learning life cycle

Understanding datasets for training and testing

Understanding machine learning tasks

Understanding Microsoft Azure Machine Learning

Understanding ML.NET

Understanding Infer.NET

Understanding ML.NET learning pipelines

Understanding model training concepts

Understanding missing values and key types

Understanding features and labels

Making product recommendations

Problem analysis

Data gathering and processing

Creating the NorthwindML website project

Creating the data and view models

Implementing the controller

Training the recommendation models

Implementing a shopping cart with recommendations

Testing the product recommendations website

Practicing and exploring

Exercise 19.1 – Test your knowledge

Exercise 19.2 – Practice with samples

Exercise 19.3 – Explore topics

Summary

Building Windows Desktop Apps

Understanding legacy Windows application platforms

Understanding .NET Core 3.0 support for legacy Windows platforms

Installing Microsoft Visual Studio 2019 for Windows

Working with Windows Forms

Building a new Windows Forms application

Reviewing a new Windows Forms application

Migrating a legacy Windows Forms application

Migrating a Windows Forms app

Migrating WPF apps to .NET Core 3.0

Migrating legacy apps using the Windows Compatibility Pack

Understanding the modern Windows platform

Understanding Universal Windows Platform

Understanding Fluent Design System

Filling user interface elements with acrylic brushes

Connecting user interface elements with animations

Parallax views and Reveal lighting

Understanding XAML Standard

Simplifying code using XAML

Choosing common controls

Understanding markup extensions

Creating a modern Windows app

Enabling developer mode

Creating a UWP project

Exploring common controls and acrylic brushes

Exploring Reveal

Installing more controls

Using resources and templates

Sharing resources

Replacing a control template

Using data binding

Binding to elements

Creating an HTTP service to bind to

Downloading the web service's certificate

Binding to data from a secure HTTP service

Creating the user interface to call the HTTP service

Converting numbers to images

Testing the HTTP service data binding

Practicing and exploring

Exercise 20.1 – Test your knowledge

Exercise 20.2 – Explore topics

Summary

Building Cross-Platform Mobile Apps Using Xamarin.Forms

Understanding Xamarin and Xamarin.Forms

How Xamarin.Forms extends Xamarin

Mobile first, cloud first

Understanding additional functionality

Understanding the INotificationPropertyChanged interface

Understanding dependency services

Understanding Xamarin.Forms user interface components

Understanding the ContentPage view

Understanding the Entry and Editor controls

Understanding the ListView control

Building mobile apps using Xamarin.Forms

Adding Android SDKs

Creating a Xamarin.Forms solution

Creating an entity model with two-way data binding

Creating a component for dialing phone numbers

Creating views for the customers list and customer details

Implementing the customer list view

Implementing the customer detail view

Setting the main page for the mobile app

Testing the mobile app

Consuming a web service from a mobile app

Configuring the web service to allow insecure requests

Configuring the iOS app to allow insecure connections

Adding NuGet packages for consuming a web service

Getting customers from the web service

Practicing and exploring

Exercise 21.1 – Test your knowledge

Exercise 21.2 - Explore topics

Summary

Epilogue

Landmarks

Cover

Index

Preface

There are C# books that are thousands of pages long that aim to be comprehensive references to the C# programming language and the .NET Framework.

This book is different. It is concise and aims to be a brisk, fun read that is packed with practical hands-on walkthroughs of each subject. The breadth of the overarching narrative comes at the cost of some depth, but you will find many signposts to explore further if you wish. This book is simultaneously a step-by-step guide to learning modern C# proven practices using cross-platform .NET and a brief introduction to the main types of applications that can be built with them. This book is best for beginners to C# and .NET, or programmers who have worked with C# in the past but feel left behind by the changes in the past few years. If you already have experience with C# 5.0 or later, then in the first topic of Chapter 2, Speaking C#, you can review tables of the new language features and jump straight to them. If you already have experience with .NET Core 1.0 or later, then in the first topic of Chapter 7, Understanding and Packaging .NET Types, you can review tables of the new platform features and jump straight to them.

I will point out the cool corners and gotchas of C# and .NET, so you can impress colleagues and get productive fast. Rather than slowing down and boring some readers by explaining every little thing, I will assume that you are smart enough to Google an explanation for topics that are related but not necessary to include in a beginner-to-intermediate guide.

You can download solutions for the step-by-step guided tasks and exercises from the following GitHub repository. If you don't know how, then I provide instructions on how to do this using Visual Studio Code at the end of Chapter 1, Hello, C#! Welcome, .NET!

https://github.com/markjprice/cs7dotnetcore2

What this book covers

Chapter 1, Hello, C#! Welcome, .NET!, is about setting up your development environment and using Visual Studio Code to create the simplest application possible with C# and .NET. You will learn how to write and compile code on any of the supported operating systems: Windows, macOS, and Linux variants. You will also learn the best places to look for help.

Chapter 2, Speaking C#, introduces the versions of C# and has tables of which version introduced new features, and then explains the grammar and vocabulary that you will use every day to write the source code for your applications. In particular, you will learn how to declare and work with variables of different types, and about the big change in C# 8.0 with the introduction of nullable reference types.

Chapter 3, Controlling Flow and Converting Types, covers using operators to perform simple actions on variables including comparisons, writing code that makes decisions, repeats a block of statements, and converts between types. It also covers writing code defensively to handle errors when they inevitably occur.

Chapter 4, Writing, Debugging, and Testing Functions, is about following the Don't Repeat Yourself (DRY) principle by writing reusable functions. You will also learn how to use debugging tools to track down and remove bugs, monitoring your code while it executes to diagnose problems, and rigorously testing your code to remove bugs and ensure stability and reliability before it gets deployed into production.

Chapter 5, Building Your Own Types with Object-Oriented Programming, discusses all the different categories of members that a type can have, including fields to store data and methods to perform actions. You will use OOP concepts, such as aggregation and encapsulation. You will learn language features such as tuple syntax support and out variables, and default literals and inferred tuple names.

Chapter 6, Implementing Interfaces and Inheriting Classes, explains deriving new types from existing ones using object-oriented programming (OOP). You will learn how to define operators and local functions, delegates and events, how to implement interfaces about base and derived classes, how to override a type member, how to use polymorphism, how to create extension methods, and how to cast between classes in an inheritance hierarchy.

Chapter 7, Understanding and Packaging .NET Types, introduces the versions of .NET Core and has tables of which version introduced new features, then presents .NET Core types that are compliant with .NET Standard, and how they relate to C#. You will learn how to deploy and package your own apps and libraries.

Chapter 8, Working with Common .NET Types, discusses the types that allow your code to perform common practical tasks, such as manipulating numbers and text, storing items in collections, and implementing internationalization.

Chapter 9, Working with Files, Streams, and Serialization, talks about interacting with the filesystem, reading and writing to files and streams, text encoding, and serialization formats like JSON and XML.

Chapter 10, Protecting Your Data and Applications, is about protecting your data from being viewed by malicious users using encryption and from being manipulated or corrupted using hashing and signing. You will also learn about authentication and authorization to protect applications from unauthorized users.

Chapter 11, Working with Databases Using Entity Framework Core, explains reading and writing to databases, such as Microsoft SQL Server and SQLite, using the object-relational mapping (ORM) technology named Entity Framework Core.

Chapter 12, Querying and Manipulating Data Using LINQ, teaches you Language INtegrated Queries (LINQ)—language extensions that add the ability to work with sequences of items and filter, sort, and project them into different outputs.

Chapter 13, Improving Performance and Scalability Using Multitasking, discusses allowing multiple actions to occur at the same time to improve performance, scalability, and user productivity. You will learn about the async Main feature and how to use types in the System.Diagnostics namespace to monitor your code to measure performance and efficiency.

Chapter 14, Practical Applications of C# and .NET, introduces you to the types of cross-platform applications that can be built using C# and .NET.

Chapter 15, Building Websites Using ASP.NET Core Razor Pages, is about learning the basics of building websites with a modern HTTP architecture on the server-side using ASP.NET Core. You will learn how to implement the ASP.NET Core feature known as Razor Pages, which simplifies creating dynamic web pages for small websites.

Chapter 16, Building Websites Using the Model-View-Controller Pattern, is about learning how to build large, complex websites in a way that is easy to unit test and manage with teams of programmers using ASP.NET Core MVC. You will learn about startup configuration, authentication, routes, models, views, and controllers.

Chapter 17, Building Websites Using a Content Management System, explains how a web Content Management System (CMS) can enable developers to rapidly build websites with a customizable administration user interface that non-technical users can use to create and manage their own content. As an example, you will learn about a simple open source .NET Core-based one named Piranha CMS.

Chapter 18, Building and Consuming Web Services, explains building backend REST architecture web services using ASP.NET Core Web API and how to properly consume them using factory-instantiated HTTP clients.

Chapter 19, Building Intelligent Apps Using Machine Learning, introduces you to Microsoft's open source ML.NET package of machine learning algorithms, which can be used to embed adaptive intelligence into any cross-platform .NET app, such as a digital commerce website that provides product recommendations for visitors to add to their shopping cart.

Chapter 20, Building Windows Desktop Apps, is the first of two chapters about topics that go beyond what is achievable using cross-platform .NET Core and Visual Studio Code. This chapter introduces you to how .NET Core 3.0 and its Windows Desktop Pack enable Windows Forms and WPF apps to benefit from running on .NET Core. You will then learn the basics of XAML, which can be used to define the user interface for a graphical app for Windows Presentation Foundation (WPF) or the Universal Windows Platform (UWP). You will apply principles and features of Fluent Design to light up a UWP app. The apps for this chapter must be built using Visual Studio 2019 on Windows 10.

Chapter 21, Building Cross-Platform Mobile Apps Using Xamarin.Forms, introduces you to taking C# mobile by building a cross-platform app for iOS and Android. The app for this chapter will be built using Visual Studio 2019 for Mac on macOS.

Appendix, Answers to the Test Your Knowledge Questions, has the answers to the test questions at the end of each chapter. You can read this appendix at https://static.packt-cdn.com/downloads/9781788478120_Appendix_Answers_to_the_Test_Your_Knowledge_Questions.pdf.

What you need for this book

You can develop and deploy C# and .NET Core apps using Visual Studio Code on many platforms, including Windows, macOS, and many varieties of Linux. An operating system that supports Visual Studio Code and an internet connection is all you need to complete Chapters 1 to 19.

You will need Windows 10 to build the apps in Chapter 20, Building Windows Desktop Apps.

You will need macOS to build the apps in Chapter 21, Building Cross-Platform Mobile Apps Using Xamarin.Forms, because you must have macOS and Xcode to compile iOS apps.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: The Controllers, Models, and Views folders contain ASP.NET Core classes and the  .cshtml files for execution on the server.

A block of code is set as follows:

// storing items at index positions

names[0] = Kate;

names[1] = Jack;

names[2] = Rebecca;

names[3] = Tom;

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

// storing items at index positions

names[0] = Kate;

names[1] = Jack;

names[2] = Rebecca;

names[3] = Tom;

Any command-line input or output is written as follows:

dotnet new console

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: "Clicking on the Next button moves you to the next screen."

More Information: Links to external sources of further reading appear in a box like this.

Good Practice: Recommendations for how to program like an expert appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply email [email protected], and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www. packtpub.com. If you purchased this book elsewhere, you can visit http://www. packtpub.com/supportand register to have the files emailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your email address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/CSharp-8.0-and-.NET-Core-3.0-Modern-Cross-Platform-Development-Fourth-Edition. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Downloading the color images of this book

We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output.

You can download this file from https://static.packt-cdn.com/downloads/9781788478120_ColorImages.pdf.

Get in touch

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book we would be grateful if you would report this to us. Please visit, www.packtpub.com/support/errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.

Piracy: If you come across any illegal copies of our works in any form on the Internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

Reviews

Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!

For more information about Packt, please visit packt.com.

Chapter 01

Hello, C#! Welcome, .NET!

In this first chapter, the goals are setting up your development environment, understanding the similarities and differences between .NET Core, .NET Framework, and .NET Standard, and then creating the simplest application possible with C# and .NET Core using Microsoft's Visual Studio Code.

After this first chapter, this book can be divided into three parts: first, the grammar and vocabulary of the C# language; second, the types available in .NET Core for building app features; and third, examples of common cross-platform apps you can build using C# and .NET. The last two chapters are about two types of application that can be built with C# but the first is not cross-platform and the second does not use .NET Core yet so they should be considered bonus chapters.

Most people learn complex topics best by imitation and repetition rather than reading a detailed explanation of the theory; therefore I will not overload you with detailed explanations of every step throughout this book. The idea is to get you to write some code, build an application from that code, and then for you to see it run.

You don't need to know all the nitty-gritty details immediately. That will be something that comes with time as you build your own apps and go beyond what any book can teach you.

In the words of Samuel Johnson, author of the English dictionary in 1755, I have committed a few wild blunders, and risible absurdities, from which no work of such multiplicity is free. I take sole responsibility for these and hope you appreciate the challenge of my attempt to lash the wind by writing this book about rapidly evolving technologies like C# and .NET Core, and the apps that you can build with them.

This first chapter covers the following topics:

Setting up your development environment

Understanding .NET

Building console apps using Visual Studio Code

Downloading solution code from a GitHub repository

Looking for help

Setting up your development environment

Before you start programming, you'll need a code editor for C#. Microsoft has a family of code editors and Integrated Development Environments (IDEs), which include:

Visual Studio Code

Visual Studio 2019

Visual Studio 2019 for Mac

Using Visual Studio Code for cross-platform development

The most modern and lightweight code editor to choose, and the only one from Microsoft that is cross-platform, is Microsoft Visual Studio Code. It is able to run on all common operating systems, including Windows, macOS, and many varieties of Linux, including Red Hat Enterprise Linux (RHEL) and Ubuntu.

Visual Studio Code is a good choice for modern cross-platform development because it has an extensive and growing set of extensions to support many languages beyond C#, and being cross-platform and lightweight it can be installed on all platforms that your apps will be deployed to for quick bug fixes and so on.

Using Visual Studio Code means a developer can use a cross-platform code editor to developer cross-platform apps. Therefore, I have chosen to use Visual Studio Code for all but the last two chapters for this book, because they need special features not available in Visual Studio Code for building Windows and mobile apps.

More Information: You can read about Microsoft's plans for Visual Studio Code at the following link: https://github.com/Microsoft/vscode/wiki/Roadmap.

If you prefer to use Visual Studio 2019 or Visual Studio for Mac instead of Visual Studio Code, then of course you can, but I will assume that you are already familiar with how to use them and so I will not give step-by-step instructions for using them in this book.

More Information: You can read a comparison of Visual Studio Code and Visual Studio 2019 at the following link: https://www.itworld.com/article/3403683/visual-studio-code-stepping-on-visual-studios-toes.html.

Using Visual Studio 2019 for Windows app development

Microsoft Visual Studio 2019 only runs on Windows, version 7 SP1 or later. You must run it on Windows 10 to create Universal Windows Platform (UWP) apps. It is the only Microsoft developer tool that can create Windows apps, so we will use it in Chapter 20, Building Windows Desktop Apps.

Using Visual Studio for Mac for mobile development

To create apps for the Apple operating systems like iOS to run on devices like iPhone and iPad, you must have Xcode, but that tool only runs on macOS. Although you can use Visual Studio 2019 on Windows with its Xamarin extensions to write a cross-platform mobile app, you still need macOS and Xcode to compile it.

So, we will use Visual Studio 2019 for Mac on macOS in Chapter 21, Building Cross-Platform Mobile Apps Using Xamarin.Forms.

Recommended tools for chapters

To help you to set up the best environment to use in this book, the following table summarizes which tools and operating systems I recommend be used for each of the chapters in this book:

To write this book, I used my MacBook Pro and the following listed software:

Visual Studio Code on macOS as my primary code editor.

Visual Studio Code on Windows 10 in a virtual machine to test OS-specific behavior like working with the filesystem.

Visual Studio 2019 on Windows 10 in a virtual machine to build Windows apps.

Visual Studio 2019 for Mac on macOS to build mobile apps.

More Information: Google and Amazon are supporters of Visual Studio Code, as you can read at the following link: https://www.cnbc.com/2018/12/20/microsoft-cmo-capossela-says-google-employees-use-visual-studio-code.html.

Deploying cross-platform

Your choice of code editor and operating system for development does not limit where your code gets deployed.

.NET Core 3.0 supports the following platforms for deployment:

Windows: Windows 7 SP1, or later. Windows 10 version 1607, or later. Windows Server 2012 R2 SP1, or later. Nano Server version 1803, or later.

Mac: macOS High Sierra (version 10.13), or later.

Linux: RHEL 6, or later. RHEL, CentOS, Oracle Linux version 7, or later. Ubuntu 16.04, or later. Fedora 29, or later. Debian 9, or later. openSUSE 15, or later.

More Information: You can read the official list of supported operating systems at the following link: https://github.com/dotnet/core/blob/master/release-notes/3.0/3.0-supported-os.md.

Understanding Microsoft Visual Studio Code versions

Microsoft releases a new feature version of Visual Studio Code (almost) every month and bug fix versions more frequently. For example:

Version 1.38, August 2019 feature release.

Version 1.38.1, August 2019 bug fix release.

More Information: You can read about the latest versions at the following link: https://code.visualstudio.com/updates.

The version used in this book is 1.38.1 released on 11 September 2019, but the version of Microsoft Visual Studio Code is less important than the version of the C# for Visual Studio Code extension that you will install later.

While the C# extension is not required, it provides IntelliSense as you type, code navigation, and debugging features, so it's something that's very handy to install. To support C# 8.0, you should install C# extension version 1.21.3 or later.

In this book, I will show keyboard shortcuts and screenshots of Visual Studio Code using the macOS version. Visual Studio Code on Windows and variants of Linux are practically identical, although keyboard shortcuts are likely different.

Some common keyboard shortcuts that we will use are shown in the following table:

I recommend that you download a PDF of keyboard shortcuts for your operating system from the following list:

Windows: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf

macOS:https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf

Linux:https://code.visualstudio.com/shortcuts/keyboard-shortcuts-linux.pdf

More Information: You can learn about the default key bindings for Visual Studio Code and how to customize them at the following link: https://code.visualstudio.com/docs/getstarted/keybindings.

Visual Studio Code has rapidly improved over the past couple of years and has pleasantly surprised Microsoft with its popularity. If you are brave and like to live on the bleeding edge, then there is an Insiders edition, which is a daily build of the next version.

Downloading and installing Visual Studio Code

Now you are ready to download and install Visual Studio Code, its C# extension, and the .NET Core 3.0 SDK.

Download and install either the Stable build or the Insiders edition of Visual Studio Code from the following link: https://code.visualstudio.com/.

Download and install the .NET Core SDK from the following link: https://www.microsoft.com/net/download.

To install the C# extension, you must first launch the Visual Studio Code application.

In Visual Studio Code, click the Extensions icon or navigate to View | Extensions.

C# is one of the most popular extensions available, so you should see it at the top of the list, or you can enter C# in the search box, as shown in the following screenshot:

Click Install and wait for supporting packages to download and install.

More Information: You can read more about Visual Studio Code support for C# at the following link: https://code.visualstudio.com/docs/languages/csharp.

Installing other extensions

In later chapters of this book, you will use more extensions. If you want to install them now, all the extensions that we will use are shown in the following table:

Understanding .NET

.NET Framework, .NET Core, Xamarin, and .NET Standard are related and overlapping platforms for developers used to build applications and services. In this section, we're going to introduce you to each of these .NET concepts.

Understanding the .NET Framework

.NET Framework is a development platform that includes a Common Language Runtime (CLR), which manages the execution of code, and a Base Class Library (BCL), which provides a rich library of classes to build applications from. Microsoft originally designed the .NET Framework to have the possibility of being cross-platform, but Microsoft put their implementation effort into making it work best with Windows.

Since .NET Framework 4.5.2 it has been an official component of the Windows operating system. .NET Framework is installed on over one billion computers so it must change as little as possible. Even bug fixes can cause problems,