C# 7 and .NET Core 2.0 High Performance电子书

Title Page

Copyright and Credits

C# 7 and .NET Core 2.0 High Performance

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

What's New in .NET Core 2 and C# 7?

Evolution of .NET

New improvements in .NET Core 2.0

Performance improvements

RyuJIT compiler in .NET Core

Profile guided optimization

Simplified packaging

Upgrading path from .NET Core 1.x to 2.0

1. Install .NET Core 2.0

2. Upgrade TargetFramework

3. Update .NET Core SDK version

4. Update .NET Core CLI

Changes in ASP.NET Core Identity

Exploring .NET Core CLI and New Project Templates

Understanding .NET Standard

Versioning of .NET Standard

New improvements in .NET Standard 2.0

More APIs in .NET Standard 2.0

Compatibility mode

Creating a .NET Standard library

What comes with ASP.NET Core 2.0

ASP.NET Core Razor Pages

Automatic Page and View compilation on publishing

Razor support for C# 7.1

Simplified configuration for Application Insights

Pooling connections in Entity Framework Core 2.0

New features in C# 7.0

Tuples

Patterns

Constant pattern

Type pattern

Var pattern

Reference returns

Expression bodied member extended

Creating Local Functions

Out variables

Async Main

Writing quality code

Summary

Understanding .NET Core Internals and Measuring Performance

.NET Core internals

CoreFX

CoreCLR

Understanding MSIL, CLI, CTS, and CLS

How the CLR works

From compilation to execution – Under the hood

Garbage collection

Generations in GC

.NET Native and JIT compilation

Utilizing multiple cores of the CPU for high performance

How releasing builds increases performance

Benchmarking .NET Core 2.0 applications

Exploring BenchmarkDotNet

How it works

Setting parameters

Memory diagnostics using BenchmarkDotnet

Adding configurations

Summary

Multithreading and Asynchronous Programming in .NET Core

Multithreading versus asynchronous programming

Multithreading in .NET Core

Multithreading caveats

Threads in .NET Core

Creating threads in .NET Core

Thread lifetime

The thread pool in .NET

Thread synchronization

Monitors

Task parallel library (TPL)

Creating a task using TPL

Task-based asynchronous pattern (TAP)

Naming convention

Return type

Parameters

Exceptions

Task status

Task cancellation

Task progress reporting

Implementing TAP using compilers

Implementing TAP with greater control over Task

Design patterns for parallel programming

Pipeline pattern

Dataflow pattern

Producer/consumer pattern

Parallel.ForEach

Parallel LINQ (PLINQ)

Summary

Data Structures and Writing Optimized Code in C#

What are data structures?

Understanding the use of Big O notation to measure the performance and complexity of an algorithm

Logarithms

Choosing the right data structure for performance optimization

Arrays

Lists

Stacks

Queue

Linked lists

Singly linked lists

Doubly linked lists

Circular linked lists

Dictionaries, hashtables, and hashsets

Generic lists

Best practices in writing optimized code in C#

Boxing and unboxing overhead

String concatenation

Exception handling

For and foreach

Delegates

Summary

Designing Guidelines for .NET Core Application Performance

Coding principles

Naming convention

Code comments

One class per file

One logic per method

Design principles

KISS (Keep It Simple, Stupid)

YAGNI (You Aren't Gonna Need It)

DRY (Don't Repeat Yourself)

Separation of Concerns (SoC)

SOLID principles

Single Responsibility Principle

Open Closed principle

Parameters

Inheritance

Composition

Liskov principle

The Interface Segregation principle

The Dependency Inversion principle

Caching

Data structures

Communication

Using lighter interfaces

Minimizing message size

Queuing communication

Resource management

Avoiding improper use of threads

Disposing objects in a timely fashion

Acquiring resources when they are required

Concurrency

Summary

Memory Management Techniques in .NET Core

Memory allocation process overview

Analysing CLR internals through the SOS debugger in .NET Core

Memory fragmentation

Avoiding finalizers

Best practices for disposing of objects in .NET Core

Introduction to the IDisposable interface

What are unmanaged resources?

Using IDisposable

When to implement the IDisposable interface

Finalizer and Dispose

Summary

Securing and Implementing Resilience in .NET Core Applications

Introduction to resilient applications

Resilient policies

Reactive policies

Implementing the retry pattern

Implementing circuit breaker

Wrapping the circuit breaker with retry

Fallback policy with circuit breaker and retry

Proactive policies

Implementing timeout

Implementing caching

Implementing health checks

Storing sensitive information using Application Secrets

Protecting ASP.NET Core APIs

SSL (Secure Socket Layer)

Enabling SSL in an ASP.NET Core application

Preventing CSRF (Cross-Site Request Forgery) attacks

Reinforcing security headers

Adding the HTTP strict transport security header

Adding the X-Content-Type-Options header

Adding the X-Frame-Options header

Adding the X-Xss-Protection header

Adding the Content-Security-Policy header

Adding the referrer-policy header

Enabling CORS in the ASP.NET Core application

Authentication and authorization

Using ASP.NET Core Identity for authentication and authorization

Authentication

Authorization

Implementing authentication and authorization using the ASP.NET Core Identity framework

Adding more properties in the user table

Summary

Microservices Architecture

Microservices architecture

Benefits of microservices architecture

Standard practice when developing microservices

Types of microservices

Stateless microservices

Stateful microservices

DDD

Data manipulation with microservices

Wrapping microservices behind an API gateway

Denormalizing data into a flat schema for read/query purposes

Consistency across business scenarios

Communication with microservices

Database architecture in microservices

Tables per service

Database per service

Challenges in segregating tables or databases per service

What is API composition?

CQRS

Developing microservices architecture with .NET Core

Creating a sample app in .NET Core using microservices architecture

Solution structure

Logical architecture

Developing a Core infrastructure project

Creating the BaseEntity class

The UnitOfWork pattern

Creating a repository interface

Logging

Creating the APIComponents infrastructure project

Developing an identity service for user authorization

OpenIddict connect flows

Creating the identity service project

Implementing the vendor service

Creating a vendor domain

Creating the vendor infrastructure

Creating the vendor service

Implementing the mediator pattern in the vendor service

Deploying microservices on Docker containers

What is Docker?

Using Docker with .NET Core

Running Docker images

Summary

Monitoring Application Performance Using Tools

Application performance key metrics

Average response time

Apdex scores

Percentage of errors

Request rate

Throughput/endpoints

CPU and memory usage

Tools and techniques to measure performance

Introducing App Metrics

Setting up App Metrics with ASP.NET Core

Tracking middleware

Adding tracking middleware

Setting up configuration

Adding visual reports

Setting up InfluxDB

Setting up the Windows subsystem for Linux

Installing InfluxDB

Installing Grafana

Adding the InfluxDB dashboard

Configuring InfluxDB

Modifying the Configure and ConfigureServices methods in Startup

Testing the ASP.NET Core App and reporting on the Grafana dashboard

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think