Book Image

High-Performance Programming in C# and .NET

By : Jason Alls
Book Image

High-Performance Programming in C# and .NET

By: Jason Alls

Overview of this book

Writing high-performance code while building an application is crucial, and over the years, Microsoft has focused on delivering various performance-related improvements within the .NET ecosystem. This book will help you understand the aspects involved in designing responsive, resilient, and high-performance applications with the new version of C# and .NET. You will start by understanding the foundation of high-performance code and the latest performance-related improvements in C# 10.0 and .NET 6. Next, you’ll learn how to use tracing and diagnostics to track down performance issues and the cause of memory leaks. The chapters that follow then show you how to enhance the performance of your networked applications and various ways to improve directory tasks, file tasks, and more. Later, you’ll go on to improve data querying performance and write responsive user interfaces. You’ll also discover how you can use cloud providers such as Microsoft Azure to build scalable distributed solutions. Finally, you’ll explore various ways to process code synchronously, asynchronously, and in parallel to reduce the time it takes to process a series of tasks. By the end of this C# programming book, you’ll have the confidence you need to build highly resilient, high-performance applications that meet your customer's demands.

Related Content you might be interested in

Current Title:

Small book image
High-Performance Programming in C# and .NET
Jason Alls
Jul, 2022 | 660 pages
Small book image
Clean Code in C#
Jason Alls
Jul, 2020 | 500 pages
Small book image
C# 7 and .NET Core 2.0 High Performance
Ovais Mehboob Ahmed Khan
Apr, 2018 | 300 pages
Small book image
Learn C# Programming
Ankit Sharma | Raffaele Rialdi | Marius Bancila
Apr, 2020 | 636 pages
Table of Contents (22 chapters)
Preface
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
Share Your Thoughts
1
Part 1: High-Performance Code Foundation
Part 1: High-Performance Code Foundation
Free Chapter
2
Chapter 1: Introducing C# 10.0 and .NET 6
Chapter 1: Introducing C# 10.0 and .NET 6
Technical requirements
Overview of Microsoft .NET 6
Overview of C# 10.0
Native compilation
Improving Windows Store performance
Improving ASP.NET performance
Summary
Questions and exercises
Further reading
3
Chapter 2: Implementing C# Interoperability
Chapter 2: Implementing C# Interoperability
Technical requirements
Using Platform Invocation (P/Invoke)
Interacting with Python code
Performing Component Object Model (COM) interoperability
Safely disposing of unmanaged code
Summary
Questions
4
Chapter 3: Predefined Data Types and Memory Allocations
Chapter 3: Predefined Data Types and Memory Allocations
Technical requirements
Understanding the predefined .NET data types
Understanding the various types of memory used in C#
Passing by value and passing by reference
Boxing and unboxing
Summary
Questions
Further reading
5
Chapter 4: Memory Management
Chapter 4: Memory Management
Technical requirements
Object generations and avoiding memory issues
Understanding long and short weak references
Finalization
Implementing the IDisposable pattern
Preventing memory leaks
Summary
Questions
Further reading
6
Chapter 5: Application Profiling and Tracing
Chapter 5: Application Profiling and Tracing
Technical requirements
Understanding code metrics
Performing static code analysis
Generating and viewing memory dumps
Viewing loaded modules
Debugging your applications
Using tracing and diagnostics tools
Installing and using dotnet-counters
Tracking down and fixing a memory leak with dotMemory
Finding the cause of a UI freeze with dotTrace
Optimizing application performance and memory traffic with dotTrace
Summary
Questions
Further reading
7
Part 2: Writing High-Performance Code
Part 2: Writing High-Performance Code
8
Chapter 6: The .NET Collections
Chapter 6: The .NET Collections
Technical requirements
Understanding the different collection offerings
Understanding Big O notation
Setting up our sample database
Deciding between interfaces and concrete classes
Deciding between using arrays or collections
Accessing objects using indexers
Comparing IEnumerable and IEnumerator
Database query performance
Exploring the yield keyword
Learning the difference between concurrency and parallelism
Learning the difference between Equals() and ==
Summary
Questions
Further reading
9
Chapter 7: LINQ Performance
Chapter 7: LINQ Performance
Technical requirements
Setting up a sample database
Setting up our in-memory sample data
Database query performance
Getting the last value of a collection
Avoid using the let keyword in LINQ queries
Increasing Group By performance in LINQ queries
Filtering lists
Understanding closures
Summary
Questions
Further reading
10
Chapter 8: File and Stream I/O
Chapter 8: File and Stream I/O
Technical requirements
Understanding the various Windows file path formats
Considering improved I/O performance
Handling I/O operation exceptions
Performing memory tasks efficiently
Understanding local storage tasks
Summary
Questions
Further reading
11
Chapter 9: Enhancing the Performance of Networked Applications
Chapter 9: Enhancing the Performance of Networked Applications
Technical requirements
Understanding the network layers and protocols
Improving web-based network traffic
High-performance communication using gRPC
Optimizing internet resources
Using pipelines for content streaming
Caching resources in memory
Summary
Questions
Further reading
12
Chapter 10: Setting Up Our Database Project
Chapter 10: Setting Up Our Database Project
Technical requirements
Setting up our database
Setting up our database access project
Writing the SecretsManager
Writing the Product class
Writing the SqlCommandModel class
Writing the SqlCommandParameterModel class
Writing the AdoDotNet class
Writing the EntityFrameworkCoreData class
Writing the DapperDotNet class
Summary
Further reading
13
Chapter 11: Benchmarking Relational Data Access Frameworks
Chapter 11: Benchmarking Relational Data Access Frameworks
Technical requirements
Benchmarking data insertion methods
Benchmarking data selection methods
Benchmarking data editing methods
Benchmarking data deletion methods
The benchmarking results and their analysis
Summary
Questions
Further reading
14
Chapter 12: Responsive User Interfaces
Chapter 12: Responsive User Interfaces
Technical requirements
Building a responsive UI with WinForms
Building a responsive UI with WPF
Building a responsive UI with ASP.NET
Building responsive UIs with .NET MAUI
Building a responsive UI with MAUI
Building a responsive UI with WinUI 3
Summary
Questions
Further reading
15
Chapter 13: Distributed Systems
Chapter 13: Distributed Systems
Technical requirements
Implementing the CQRS design pattern
Implementing event sourcing
Using Microsoft Azure for distributed systems
Managing your cloud infrastructure with Pulumi
Performance considerations for distributed computing
Summary
Questions
Further reading
16
Part 3: Threading and Concurrency
Part 3: Threading and Concurrency
17
Chapter 14: Multi-Threaded Programming
Chapter 14: Multi-Threaded Programming
Technical requirements
Understanding threads and threading
Creating threads and using parameters
Pausing and interrupting threads
Destroying and canceling threads
Scheduling threads
Thread synchronization and locking
Summary
Questions
Further reading
18
Chapter 15: Parallel Programming
Chapter 15: Parallel Programming
Technical requirements
Using the Task Parallel Library (TPL)
Using Parallel LINQ (PLINQ)
Benchmarking with BenchmarkDotNet
Using lambda expressions with TPL and LINQ
Parallel debugging and profiling tools
Summary
Questions
Further reading
19
Chapter 16: Asynchronous Programming
Chapter 16: Asynchronous Programming
Technical requirements
Understanding the TAP model
async, await, and Task
Benchmarking GetAwaiter.GetResult(), .Result, and .Wait for both Task and ValueTask
Using async, await, and WhenAll
Canceling asynchronous operations
Writing files asynchronously
Reading files asynchronously
Summary
Questions
Further reading
20
Assessments
Assessments
Chapter 1, Introducing C# 10.0 and .NET 6
Chapter 2, Implementing C# Interoperability
Chapter 3, Predefined Data Types and Memory Allocations
Chapter 4, Memory Management
Chapter 5, Application Profiling and Tracing
Chapter 6, The .NET Collections
Chapter 7, LINQ Performance
Chapter 8, File and Stream I/O
Chapter 9, Enhancing the Performance of Networked Applications
Chapter 10, Setting Up Our Database Project
Chapter 11, Benchmarking Relational Data Access Frameworks
Chapter 12, Responsive User Interfaces
Chapter 13, Distributed Systems
Chapter 14, Multi-Threaded Programming
Chapter 15, Parallel Programming
Chapter 16, Asynchronous Programming
Why subscribe?
21
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Writing the SecretsManager

In this section, we are going to update our SecretsManager class so that we can safely obtain secrets.

Note

Our development environment will use a secrets.json file. This is very serious as private credentials have been found and accessed on source code hosting sites such as GitHub before now, and we don't want to be the ones responsible for checking in code that contains secrets that should be kept private.

Follow these steps:

  1. Add the following NuGet packages:
    Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.JsonFile
Microsoft.Extensions.Configuration.EnvironmentVariables
Microsoft.Extensions.Configuration.UserSecrets

We need these packages so that we can configure the project for user secrets and appsettings.json.

  1. Open the SecretsManager class and add the following using statements:
    using Microsoft.Extensions.Configuration;
using System;
using System.IO;

We need these using statements for our...

Previous Section
End of Section 5
Next Section