舉報 
會員
C# 7 and .NET Core 2.0 High Performance
Thisbookisfor.NETdeveloperslookingatimprovingthespeedoftheircodeorsimplywantingtotaketheirskillstothenextlevel.BasicC#knowledgeisassumed.
最新章節
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Summary
- Testing the ASP.NET Core App and reporting on the Grafana dashboard
- Modifying the Configure and ConfigureServices methods in Startup
- Configuring InfluxDB
品牌：中圖公司
上架時間：2021-08-27 18:05:34
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-08-27 18:47:46
- Other Books You May Enjoy
- Summary
- Testing the ASP.NET Core App and reporting on the Grafana dashboard
- Modifying the Configure and ConfigureServices methods in Startup
- Configuring InfluxDB
- Adding the InfluxDB dashboard
- Installing Grafana
- Installing InfluxDB
- Setting up the Windows subsystem for Linux
- Setting up InfluxDB
- Adding visual reports
- Setting up configuration
- Adding tracking middleware
- Tracking middleware
- Setting up App Metrics with ASP.NET Core
- Introducing App Metrics
- Tools and techniques to measure performance
- CPU and memory usage
- Throughput/endpoints
- Request rate
- Percentage of errors
- Apdex scores
- Average response time
- Application performance key metrics
- Monitoring Application Performance Using Tools
- Summary
- Running Docker images
- Using Docker with .NET Core
- What is Docker?
- Deploying microservices on Docker containers
- Implementing the mediator pattern in the vendor service
- Creating the vendor service
- Creating the vendor infrastructure
- Creating a vendor domain
- Implementing the vendor service
- Creating the identity service project
- OpenIddict connect flows
- Developing an identity service for user authorization
- Creating the APIComponents infrastructure project
- Logging
- Creating a repository interface
- The UnitOfWork pattern
- Creating the BaseEntity class
- Developing a Core infrastructure project
- Logical architecture
- Solution structure
- Creating a sample app in .NET Core using microservices architecture
- Developing microservices architecture with .NET Core
- CQRS
- What is API composition?
- Challenges in segregating tables or databases per service
- Database per service
- Tables per service
- Database architecture in microservices
- Communication with microservices
- Consistency across business scenarios
- Denormalizing data into a flat schema for read/query purposes
- Wrapping microservices behind an API gateway
- Data manipulation with microservices
- DDD
- Stateful microservices
- Stateless microservices
- Types of microservices
- Standard practice when developing microservices
- Benefits of microservices architecture
- Microservices architecture
- Microservices Architecture
- Summary
- Adding more properties in the user table
- Implementing authentication and authorization using the ASP.NET Core Identity framework
- Authorization
- Authentication
- Using ASP.NET Core Identity for authentication and authorization
- Authentication and authorization
- Enabling CORS in the ASP.NET Core application
- Adding the referrer-policy header
- Adding the Content-Security-Policy header
- Adding the X-Xss-Protection header
- Adding the X-Frame-Options header
- Adding the X-Content-Type-Options header
- Adding the HTTP strict transport security header
- Reinforcing security headers
- Preventing CSRF (Cross-Site Request Forgery) attacks
- Enabling SSL in an ASP.NET Core application
- SSL (Secure Socket Layer)
- Protecting ASP.NET Core APIs
- Storing sensitive information using Application Secrets
- Implementing health checks
- Implementing caching
- Implementing timeout
- Proactive policies
- Fallback policy with circuit breaker and retry
- Wrapping the circuit breaker with retry
- Implementing circuit breaker
- Implementing the retry pattern
- Reactive policies
- Resilient policies
- Introduction to resilient applications
- Securing and Implementing Resilience in .NET Core Applications
- Summary
- Finalizer and Dispose
- When to implement the IDisposable interface
- Using IDisposable
- What are unmanaged resources?
- Introduction to the IDisposable interface
- Best practices for disposing of objects in .NET Core
- Avoiding finalizers
- Memory fragmentation
- Analysing CLR internals through the SOS debugger in .NET Core
- Memory allocation process overview
- Memory Management Techniques in .NET Core
- Summary
- Concurrency
- Acquiring resources when they are required
- Disposing objects in a timely fashion
- Avoiding improper use of threads
- Resource management
- Queuing communication
- Minimizing message size
- Using lighter interfaces
- Communication
- Data structures
- Caching
- The Dependency Inversion principle
- The Interface Segregation principle
- Liskov principle
- Composition
- Inheritance
- Parameters
- Open Closed principle
- Single Responsibility Principle
- SOLID principles
- Separation of Concerns (SoC)
- DRY (Don't Repeat Yourself)
- YAGNI (You Aren't Gonna Need It)
- KISS (Keep It Simple Stupid)
- Design principles
- One logic per method
- One class per file
- Code comments
- Naming convention
- Coding principles
- Designing Guidelines for .NET Core Application Performance
- Summary
- Delegates
- For and foreach
- Exception handling
- String concatenation
- Boxing and unboxing overhead
- Best practices in writing optimized code in C#
- Generic lists
- Dictionaries hashtables and hashsets
- Circular linked lists
- Doubly linked lists
- Singly linked lists
- Linked lists
- Queue
- Stacks
- Lists
- Arrays
- Choosing the right data structure for performance optimization
- Logarithms
- Understanding the use of Big O notation to measure the performance and complexity of an algorithm
- What are data structures?
- Data Structures and Writing Optimized Code in C#
- Summary
- Parallel LINQ (PLINQ)
- Parallel.ForEach
- Producer/consumer pattern
- Dataflow pattern
- Pipeline pattern
- Design patterns for parallel programming
- Implementing TAP with greater control over Task
- Implementing TAP using compilers
- Task progress reporting
- Task cancellation
- Task status
- Exceptions
- Parameters
- Return type
- Naming convention
- Task-based asynchronous pattern (TAP)
- Creating a task using TPL
- Task parallel library (TPL)
- Monitors
- Thread synchronization
- The thread pool in .NET
- Thread lifetime
- Creating threads in .NET Core
- Threads in .NET Core
- Multithreading caveats
- Multithreading in .NET Core
- Multithreading versus asynchronous programming
- Multithreading and Asynchronous Programming in .NET Core
- Summary
- Adding configurations
- Memory diagnostics using BenchmarkDotnet
- Setting parameters
- How it works
- Exploring BenchmarkDotNet
- Benchmarking .NET Core 2.0 applications
- How releasing builds increases performance
- Utilizing multiple cores of the CPU for high performance
- .NET Native and JIT compilation
- Generations in GC
- Garbage collection
- From compilation to execution – Under the hood
- How the CLR works
- Understanding MSIL CLI CTS and CLS
- CoreCLR
- CoreFX
- .NET Core internals
- Understanding .NET Core Internals and Measuring Performance
- Summary
- Writing quality code
- Async Main
- Out variables
- Creating Local Functions
- Expression bodied member extended
- Reference returns
- Var pattern
- Type pattern
- Constant pattern
- Patterns
- Tuples
- New features in C# 7.0
- Pooling connections in Entity Framework Core 2.0
- Simplified configuration for Application Insights
- Razor support for C# 7.1
- Automatic Page and View compilation on publishing
- ASP.NET Core Razor Pages
- What comes with ASP.NET Core 2.0
- Creating a .NET Standard library
- Compatibility mode
- More APIs in .NET Standard 2.0
- New improvements in .NET Standard 2.0
- Versioning of .NET Standard
- Understanding .NET Standard
- Exploring .NET Core CLI and New Project Templates
- Changes in ASP.NET Core Identity
- 4. Update .NET Core CLI
- 3. Update .NET Core SDK version
- 2. Upgrade TargetFramework
- 1. Install .NET Core 2.0
- Upgrading path from .NET Core 1.x to 2.0
- Simplified packaging
- Profile guided optimization
- RyuJIT compiler in .NET Core
- Performance improvements
- New improvements in .NET Core 2.0
- Evolution of .NET
- What's New in .NET Core 2 and C# 7?
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewer
- About the author
- Contributors
- PacktPub.com
- Why subscribe?
- Packt Upsell
- C# 7 and .NET Core 2.0 High Performance
- Copyright and Credits
- Title Page
- 封面
- 封面
- 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 更新時間：2021-08-27 18:47:46
