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

Chapter 1: Introducing C# 10.0 and .NET 6

Microsoft .NET 6 and C# 10.0 are the latest incarnations of the .NET platform and C# programming language. They bring many performance enhancements to the C# and .NET programmer community. We will start this book with an overview of the new versions of C# and .NET.

In this chapter, you will start by downloading, restoring, building, and testing the latest version of the .NET compiler called Roslyn. Then, you will review what's new in .NET 6, including the areas where performance has been greatly enhanced. Then, you will review what's new in C# 10.0 by looking at some code examples that demonstrate these features.

In the Native compilation section, you will build a project and run it as an MSIL project with multiple binaries, then compile and run it as a single native binary. Finally, you will learn how to improve the performance of Windows Store applications and ASP.NET websites.

In this chapter, we will cover the following topics:

  • Overview of .NET 6: In this section, we will cover, at a high level, what's new in .NET 6. You will learn about the various performance improvements that will be part of .NET 6.
  • Overview of C# 10.0: Having learned how to obtain the latest Roslyn code in the Technical requirements section, in this section, you will learn about the various features that will be part of C# 10.0. This will include code examples.
  • Native compilation: In this section, you will learn how to compile a .NET Core application into a single native executable. You will write a simple console application that recursively converts audio files from one format into another.
  • Improving Windows Store performance: This is a brief section that provides standard guidelines for improving the performance of applications that target the Windows Store.
  • Improving ASP.NET performance: This is a brief section that provides some standard guidelines for improving ASP.NET applications.

By the end of this chapter, you will have the following skills:

  • You will understand what's new in Microsoft .NET 6.
  • You will be able to apply the new C# 10.0 code features within your source code.
  • You will be able to compile your source code to native assemblies (also known as binaries).
  • You will know what, how, and where to look for information on improving the performance of applications that target the Windows Store.
  • You will know what, how, and where to look for information on improving the performance of ASP.NET applications.

Let's begin this chapter by looking at Microsoft .NET 6.

Previous Section
End of Section 1
Next Section