ASP.NET Core 1.0 High Performance电子书

ASP.NET Core 1.0 High Performance

ASP.NET Core 1.0 High Performance

Credits

Foreword

About the Author

Acknowledgments

About the Reviewer

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. Why Performance Is a Feature

Performance as a feature

Common classes of performance problems

Language considerations

Types of performance problems

When performance matters

Slower is sometimes better

Why issues are missed

Measuring

The benefits of planning ahead

Understanding hardware

Storage access speeds

Scaling approach changes

Tools and costs

Tools

Looking at some alternative tools

The new .NET

Summary

2. Measuring Performance Bottlenecks

Tools

SQL

SQL Server Profiler

Executing a simple query

MiniProfiler

Application profiling

Glimpse

Using Glimpse

IDE

Monitoring HTTP

Browsers

Chrome

Firefox

Fiddler

Network

Microsoft Message Analyzer

Wireshark

Roll your own

Science

Repeatability

Only change one thing

Summary

3. Fixing Common Performance Problems

Latency

Asynchronous operations

Simple asynchronous tools

Background queuing

Hangfire

Select N+1 problems

Efficient paging

Static site generators

Pragmatic solutions with hardware

A desktop example

Web applications

Oversized images

Image resolution

Image format

Summary

4. Addressing Network Performance

Internet protocols

TCP/IP

Slow-start

HTTP

Headers

HTTP methods

Status codes

Encryption

Key exchange

Delay diagnostics

Performance tweaks

HTTP/2

WebSockets

Compression

Lossless compression algorithms

Bundling and minification

Bundling

Minification

Changes in ASP.NET Core

Image optimization

PNG

JPEG

Other image formats

Resizing images

Caching

Browser

Server

Proxy servers between you and your users

CDNs

Summary

5. Optimizing I/O Performance

Input/output

Categories of I/O

Disks

Virtual file systems

Databases

APIs

Network diagnostics tools

Ping

Tracert

Nslookup

Build your own

Solutions

Batching API requests

Efficient DB operations

Database tuning

Reporting

Aggregates

Sampling

Inserting data

GUIDs

Advanced DB topics

Simulation and testing

Summary

6. Understanding Code Execution and Asynchronous Operations

Getting started with the core projects

.NET Core

ASP.NET Core

Kestrel

Data structures

Lists

Dictionaries

Collection benchmarks

Bloom filters

Hashing and checksums

Hashing benchmarks

Serialization

SIMD CPU instructions

Parallel programming

Task Parallel Library

Parallel LINQ

Parallel benchmarking

Parallel programming limitations

Practices to avoid

Reflection

Regular expressions

String concatenation in tight loops

Dynamic typing

Synchronous operations

Exceptions

Summary

7. Learning Caching and Message Queuing

Why caching is hard

Web caching

Caching background

HTTP headers

Cache busting

Service workers

Service worker example

Web and proxy servers

IIS

Varnish

Working with a content delivery network

When not to cache

Application layer caching

Redis

Database result set caching

Message queuing

Coffee shop analogy

Message queuing styles

Common messaging patterns

Unicast

Pub/sub

RabbitMQ

Queuing frameworks and libraries

Summary

8. The Downsides of Performance-Enhancing Tools

Managing complexity

Understanding complexity

Complexity reduction

Frameworks

Architecture

Monolith versus microservices

Architecture comparison

Refactoring

A culture of high performance

A blameless culture

Intellectual dishonesty

Slow down to go faster

From the ground up

Shared values

The price of performance

Distributed debugging

Logging

Error logging

Application Insights

Integrated logging

Centralized logging

Statistics

Managing stale caches

Summary

9. Monitoring Performance Regressions

Profiling and measurement

Testing

Automated testing

Continuous integration

Slow testing

Fixing performance regressions

Load testing

Realism

Realistic environments

Realistic workloads

Feature switching

Experimenting for science

A/B testing

User interface testing

Web UI testing tools

Automating UI performance tests

Staying alert

DevOps

DevOps tooling

Provisioning

Monitoring

Hosting

Summary

10. The Way Ahead

Reviewing what we learned

Further reading

Going native

Processor architecture

Hardware is hard

Machine learning

Big data and MapReduce

Orleans

Custom transports

Advanced hashing

Library and framework support

The future

Summary