C# 6 and .NET Core 1.0: Modern Cross-Platform Development

Table of Contents

C# 6 and .NET Core 1.0

Credits

About the Author

About the Reviewers

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Hello, C#! Welcome, .NET Core!

Setting up your development environment

Using alternative C# IDEs

Using Visual Studio 2015 on Windows 10

Installing Microsoft Visual Studio 2015

Choosing the default installation

Choosing the custom installation

Completing the installation

Signing in to Visual Studio

Choosing development settings

Updating extensions and products

Using older versions of Visual Studio

Understanding .NET Framework, .NET Core, and .NET Native

Understanding .NET Framework platform

Understanding the Mono project

Understanding the .NET Core platform

Streamlining .NET

The future of .NET

Understanding the .NET Native platform

Comparing .NET technologies

Writing and compiling code using the Developer Command Prompt

Writing code using Notepad

Compiling code using the Developer Command Prompt

Fixing compiler errors

Decompiling code using ILDASM

Disassembling compiled assemblies

Writing and compiling code using Microsoft Visual Studio 2015

Writing code using Visual Studio 2015

Compiling code using Visual Studio

Fixing mistakes with the error list

Experimenting with C# Interactive

Other useful windows

Targeting the .NET Core

Understanding the .NET Portability Analyzer

Installing the .NET Portability Analyzer

Configuring the .NET Portability Analyzer

Analyzing a solution

.NET Portability and this book

Creating new projects for the .NET Core

Managing .NET Core development with Command Line Tools

Installing the .NET Command Line Tools

Creating a .NET Core application using Command Line Tools

Creating a .NET Core application using Visual Studio 2015

Managing source code with GitHub

Using the Team Explorer window

Cloning a GitHub repository

Managing a GitHub repository

Practicing and exploring

Exercise 1.1 – test your knowledge

Exercise 1.2 – practice managing Visual Studio Windows

Exercise 1.3 – practice coding anywhere

Exercise 1.4 – explore topics

Summary

2. Speaking C#

Understanding C# basics

The C# grammar

Statements

Blocks

The C# vocabulary

Writing the code

Verbs are methods

Nouns are types, fields, and variables

Counting types and methods

Declaring variables

Naming variables

Storing text

Storing numbers

Storing whole numbers

Storing real numbers

Sizes of numbers in memory

Comparing double and decimal

Storing Booleans

The object type

The dynamic type

Local variables

Inferring the type of a local variable

Making a value type nullable

Storing multiple values in an array

Building console applications

Displaying output to the user

Getting input from the user

Importing a namespace

Simplifying the usage of the console in C# 6

Reading arguments and working with arrays

Operating on variables

Experimenting with unary operators

Experimenting with arithmetic operators

Comparison and Boolean operators

Practicing and exploring

Exercise 2.1 – test your knowledge

Exercise 2.2 – practice number sizes and ranges

Exercise 2.3 – explore topics

Summary

3. Controlling the Flow, Converting Types, and Handling Exceptions

Selection statements

The if-else statement

The switch-case statement

Autoformatting code

Iteration statements

The while statement

The do-while statement

The for statement

The foreach statement

How does the foreach statement actually work?

Casting and converting between types

Casting from numbers to numbers

Using the Convert type

Rounding numbers

Converting from any type to a string

Parsing from strings to numbers or dates and times

Handling exceptions

The try-catch statement

Catching all exceptions

Catching specific exceptions

The finally statement

Simplifying disposal with the using statement

Checking for overflow

The checked statement

The unchecked statement

Looking for help

MSDN

Getting the definition of code

StackOverflow

Google

Design patterns

Practice and explore

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 – explore topics

Summary

4. Using Common .NET Types

Using assemblies and namespaces

Comparing .NET Framework with .NET Core

Base Class Libraries and CoreFX

Assemblies

Namespaces

Referencing an assembly

Referencing Microsoft Core Library

An example of assembly references

Relating assemblies and namespaces

Importing a namespace

Browsing assemblies and namespaces

Relating C# keywords to .NET types

Storing and manipulating text

Getting the length of a string

Getting the characters of a string

Splitting a string

Extracting part of a string

Checking a string for content

Other string members

Building strings efficiently

Validating input with regular expressions

The syntax of a regular expression

Examples of regular expressions

Storing data with collections

Understanding collections

Lists

Dictionaries

Stacks

Queues

Sets

Working with lists

Working with dictionaries

Sorting collections

Avoiding old collections

Using specialized collections

Practicing and exploring

Exercise 4.1 – test your knowledge

Exercise 4.2 – practice regular expressions

Exercise 4.3 – explore topics

Summary

5. Using Specialized .NET Types

Debugging and diagnostics

Debugging an application

Setting a breakpoint

The debugging toolbar

Debugging windows

Stepping through code

Customizing breakpoints

Monitoring performance and resource usage

Evaluating the efficiency of types

Monitoring performance and memory use

Measuring the efficiency of processing strings

Monitoring with Debug and Trace

Writing to the default trace listener

Configuring trace listeners

Configuring compiler symbols for .NET Framework

Defining compiler symbols for .NET Core

Checking compiler symbols

Switching trace levels

Unit testing an application

Creating a unit of code that needs testing

Creating a unit test project

Running unit tests

Internationalizing an application

Globalizing an application

Localizing an application

Interoperating with unmanaged code

Automating Microsoft Excel using COM Interop

Accessing the Win32 API with P/Invoke

Practicing and exploring

Exercise 5.1 – test your knowledge

Exercise 5.2 – practice using Debug and Trace

Exercise 5.3 – explore topics

Summary

6. Building Your Own Types with Object-Oriented Programming

Talking about OOP

Building class libraries

Creating a class library to share code

Defining a class

Instantiating a class

Storing data with fields

Defining fields

Storing a value using the enum keyword

Storing multiple values using collections

Making a field static

Making a field constant

Making a field read only

Initializing fields with constructors

Writing and calling methods

Overloading methods

Optional parameters and named arguments

Splitting classes using partial

Controlling access with properties and indexers

Defining read-only properties

Defining settable properties

Defining indexers

Simplifying methods with operators

Raising and handling events

Calling methods using delegates

Defining events

Practicing and exploring

Exercise 6.1 – test your knowledge

Exercise 6.2 – practice writing mathematical methods

Exercise 6.3 – explore topics

Summary

7. Implementing Interfaces and Inheriting Classes

Implementing interfaces

Common interfaces

Comparing objects when sorting

Defining a separate comparer

Managing memory with reference and value types

Defining a type using the struct keyword

Releasing unmanaged resources

Ensuring that dispose is called

Inheriting from classes

Extending classes

Hiding members

Overriding members

Preventing inheritance and overriding

Polymorphism

Casting within inheritance hierarchies

Implicit casting

Explicit casting

Handling casting exceptions

Documenting your types

Inheriting and extending .NET types

Inheriting from the Exception class

Extending types when you can't inherit

Using static methods to reuse functionality

Using extension methods to reuse functionality

Practice and explore

Exercise 7.1 – test your knowledge

Exercise 7.2 – practice creating an inheritance hierarchy

Exercise 7.3 – explore topics

Summary

8. Working with Relational Data Using the Entity Framework

Relational Database Management Systems

Connecting to Microsoft SQL Server LocalDb

The Northwind sample database

Choosing a .NET data provider

Using ADO.NET

Connecting to the database

Executing commands and reading result sets

Loading a connection string from configuration

Using Entity Framework 6

Building an Entity Framework 6 model

Entity Framework Code First models

EF Code First conventions

EF annotation attributes

EF Fluent API

Querying an Entity Data Model

Logging SQL statements

Manipulating data with Entity Data Models

Inserting entities

Updating entities

Transactions

Defining an explicit transaction

Loading patterns with EF

Lazy loading entities

Eager loading entities

Explicit loading entities

Using Entity Framework Core

Practicing and exploring

Exercise 8.1 – test your knowledge

Exercise 8.2 – explore the EF Core documentation

Exercise 8.3 – explore topics

Summary

9. Querying and Manipulating Data with 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 sequences with OrderBy

Sorting by multiple properties with the ThenBy method

Working with sets

Projecting entities with Select statement

Joining and grouping

Sweetening the syntax with syntactic sugar

Using multiple threads with Parallel LINQ

Creating your own LINQ extension methods

Working with LINQ to XML

Generating XML using LINQ to XML

Reading XML by using LINQ to XML

Practicing and exploring

Exercise 9.1 – test your knowledge

Exercise 9.2 – practice querying with LINQ

Exercise 9.3 – explore topics

Summary

10. Working with Files, Streams, and Serialization

Managing the filesystem

Managing directories

Managing files

Managing paths

Getting file information

Reading and writing with streams

Writing to text and XML streams

Compressing streams

Encoding text

Encoding strings as byte arrays

Encoding and decoding text in files

Serializing object graphs

Serializing with XML

Deserializing with XML

Customizing the XML

Serializing with JSON

Serializing with other formats

Serializing with runtime serializers

Practice and explore

Exercise 10.1 – test your knowledge

Exercise 10.2 – practice serializing as XML

Exercise 10.3 – explore serialization formats

Exercise 10.4 – explore Microsoft's System.IO types

Exercise 10.5 – explore topics

Summary

11. 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 SHA256

Signing data

Signing with SHA256 and RSA

Authenticating and authorizing users

Managing local accounts

Authenticating with Windows

Authorizing with Windows

Practicing and exploring

Exercise 11.1 – test your knowledge

Exercise 11.2 – practice protecting data with encryption and hashing

Exercise 11.3 – practice protecting data with decryption

Exercise 11.4 – explore topics

Summary

12. Improving Performance and Scalability with Multitasking

Understanding processes and threads

Running tasks asynchronously

Running multiple actions synchronously

Running multiple actions asynchronously using tasks

Waiting for tasks

Continuing with another task

Nested and child tasks

The async and await keywords

Creating a GUI that blocks

Creating a GUI that doesn't block

Other types with Async methods

await in catch blocks

Improving scalability for client-server applications

Synchronizing access to shared resources

Accessing a resource from multiple threads

Applying a mutually exclusive lock to a resource

Understanding the lock statement

Making operations atomic

Applying other types of synchronization

Practicing and exploring

Exercise 12.1 – test your knowledge

Exercise 12.2 – explore topics

Summary

13. Building Universal Windows Platform Apps Using XAML

Understanding the UWP

Adapting your app's layout

Taking advantage of unique device capabilities

Understanding XAML

Simplifying code using XAML

Creating a Windows desktop application using WPF

Choosing common controls

Creating an app for the Universal Windows Platform

Analyzing UWP portability

Using resources and templates

Sharing resources

Replacing a control template

Data binding

Binding to elements

Binding to data

Animating with storyboards

Testing in emulators

Practicing and exploring

Exercise 13.1 – test your knowledge

Exercise 13.2 – practice building a universal tip calculator

Exercise 13.3 – explore topics

Summary

14. Building Web Applications and Services Using ASP.NET Core

Understanding ASP.NET Core

Classic ASP.NET versus modern ASP.NET Core

Client-side web development

Install Web Essentials 2015

The HyperText Transfer Protocol (HTTP)

Create a web application project

Exploring the parts of an ASP.NET Core web application

ASP.NET Core startup

Understanding the default route

ASP.NET Core controllers

Defining the Home controller's actions

ASP.NET Core models

Create Entity models for Northwind

Configure Entity Framework Core as a service

Create view models for requests

Fetch the model in the controller

ASP.NET Core views

Rendering the Home controller's views

Sharing layouts between views

Defining custom styles

Defining a typed view

Taking ASP.NET Core further

Passing parameters using a route value

Passing parameters using a query string

Annotating models

ASP.NET Core Web API

Scaffolding an API controller

Calling a Web API service from a UWP app

Practicing and exploring

Exercise 14.1 – test your knowledge

Exercise 14.2 – practice building a data-driven web application

Exercise 14.3 – explore topics

Summary

15. Taking C# Cross-Platform

Understanding cross-platform development

Visual Studio Code

.NET Core 1.0

ASP.NET Core 1.0

Entity Framework Core 1.0

.NET Native

Xamarin

Cross-device Universal Windows Platform (UWP)

Installing Visual Studio Code and ASP.NET Core

Installing Visual Studio Code

Managing development from the terminal

Installing Homebrew

Installing ASP.NET Core and the .NET Version Manager

Listing the installed versions of .NET

Switching from Mono to .NET Core

Building a console application

Creating the source files

Editing the code