C# 7 and .NET Core 2.0 high performance : build highly performant, multi-threaded, and concurrent applications using C# 7 and .NET Core 2.0

C# 7 and .NET Core 2.0 high performance build highly performant, multi-threaded, and concurrent applications using C# 7 and .NET Core 2.0

Improve the speed of your code and optimize the performance of your apps About This Book Understand the common performance pitfalls and improve your application's performance Get to grips with multi-threaded and asynchronous programming in C# Develop highly performant applications on .NET Core...

Descripción completa

Detalles Bibliográficos
Otros Autores: Mehboob Ahmed Khan, Ovais, author (author)
Formato: Libro electrónico
Idioma:Inglés
Publicado: Birmingham ; Mumbai : Packt Publishing 2018.
Edición:First edition
Materias:
C# (Computer program language)
Application software > Development.
Ver en Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631497006719
Tabla de Contenidos:
  • Intro
  • Title Page
  • Copyright and Credits
  • Packt Upsell
  • Contributors
  • Table of Contents
  • Preface
  • 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
  • Index.

Ejemplares similares