book

High-Performance Programming in C# and .NET

Name: High-Performance Programming in C# and .NET
Author: Jason Alls
ISBN: 9781800564718

by Jason Alls

July 2022

Intermediate to advanced

660 pages

12h 41m

English

Packt Publishing

Read now

Unlock full access

High-Performance Programming in C# and .NET
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your Thoughts
Part 1: High-Performance Code Foundation
Chapter 1: Introducing C# 10.0 and .NET 6
Technical requirementsObtaining and building the latest Roslyn compiler from the source codeOverview of Microsoft .NET 6Moving to one unified platformGarbage collectionJust-In-Time compilerText-based processingThreading and asynchronous operationsCollections and LINQNetworking and BlazorNew performance-based APIs and analyzersOverview of C# 10.0Writing top-level programsUsing init-only propertiesUsing recordsUsing the new pattern matching featuresUsing new expressions with targeted typesUsing covariant returnsNative compilationPerforming native compilation of .NET Core applicationsImproving Windows Store performanceImproving ASP.NET performanceSummaryQuestions and exercisesFurther reading
Chapter 2: Implementing C# Interoperability
Technical requirementsUsing Platform Invocation (P/Invoke)Using unsafe and fixed codeExposing static entry points using P/InvokeInteracting with Python codePerforming Component Object Model (COM) interoperabilityReading data from an Excel spreadsheetCreating an Excel add-inSafely disposing of unmanaged codeSummaryQuestionsFurther reading
Chapter 3: Predefined Data Types and Memory Allocations
Technical requirementsUnderstanding the predefined .NET data typesUnderstanding the predefined value types in C#Understanding the predefined reference types in C#Understanding static typesUnderstanding the various types of memory used in C#The stackThe heapBuilding a stack versus building a heap (example project)Choosing between a struct and a classPassing by value and passing by referenceBuilding a pass-by-reference example programBoxing and unboxingPerforming boxingPerforming unboxingSummaryQuestionsFurther reading
Chapter 4: Memory Management
Technical requirementsObject generations and avoiding memory issuesUnderstanding long and short weak referencesFinalizationUsing finalizationImplementing the IDisposable patternPreventing memory leaksUnderstanding the dangers of using Marshal.ReleaseComObjectHow using events can be a source of memory leaksSummaryQuestionsFurther reading
Chapter 5: Application Profiling and Tracing
Technical requirementsUnderstanding code metricsApplication metricsAssembly metricsNamespace metricsType metricsMethod metricsField metricsPerforming static code analysisGenerating and viewing memory dumpsViewing loaded modulesDebugging your applicationsUsing tracing and diagnostics toolsUsing the Visual Studio 2022 Performance ProfilerUsing JetBrains dotMemoryUsing JetBrains dotTraceInstalling and using dotnet-countersCollecting data and saving it to a file for post-analysisListing .NET processes that can be monitoredListing the available list of well-known .NET countersMonitoring a .NET processTracking down and fixing a memory leak with dotMemoryFinding the cause of a UI freeze with dotTraceOptimizing application performance and memory traffic with dotTraceSummaryQuestionsFurther reading
Part 2: Writing High-Performance Code
Chapter 6: The .NET Collections
Technical requirementsUnderstanding the different collection offeringsThe System.Collections namespaceThe System.Collections.Generic namespaceThe System.Collections.Concurrent namespaceThe System.Collections.Specialized namespaceCreating custom collectionsUnderstanding Big O notationChoosing the right collectionSetting up our sample databaseDeciding between interfaces and concrete classesDeciding between using arrays or collectionsAccessing objects using indexersComparing IEnumerable and IEnumeratorDatabase query performanceExploring the yield keywordLearning the difference between concurrency and parallelismLearning the difference between Equals() and ==SummaryQuestionsFurther reading

Chapter 7: LINQ Performance
Technical requirementsSetting up a sample databaseSetting up our in-memory sample dataDatabase query performanceGetting the last value of a collectionAvoid using the let keyword in LINQ queriesIncreasing Group By performance in LINQ queriesFiltering listsUnderstanding closuresSummaryQuestionsFurther reading
Chapter 8: File and Stream I/O
Technical requirementsUnderstanding the various Windows file path formatsRemoving the maximum path length limitation using the registryRemoving the maximum path length limitation using the group policyConsidering improved I/O performanceMoving filesCalculating directory sizesAccessing files asynchronouslyWriting text to a file asynchronouslyHandling I/O operation exceptionsPerforming memory tasks efficientlyUnderstanding local storage tasksSummaryQuestionsFurther reading
Chapter 9: Enhancing the Performance of Networked Applications
Technical requirementsUnderstanding the network layers and protocolsThe TCP/IP modelWriting an example email application with the TCP/IP model Improving web-based network trafficRecording your web-applications performance using Microsoft EdgeHigh-performance communication using gRPCProgramming a simple gRPC client/server applicationProgramming a simple gRPC Blazor applicationThe blank solutionOptimizing internet resourcesUsing pipelines for content streamingWriting and running a TCP server console applicationWriting and running a TCP client console applicationCaching resources in memorySummaryQuestionsFurther reading
Chapter 10: Setting Up Our Database Project
Technical requirementsSetting up our databaseSetting up our database access projectWriting the Properties classWriting the DatabaseSettings classWriting the SecretsManagerWriting the Product classWriting the SqlCommandModel classWriting the SqlCommandParameterModel classWriting the AdoDotNet classWriting the EntityFrameworkCoreData classWriting the DapperDotNet classSummaryFurther reading
Chapter 11: Benchmarking Relational Data Access Frameworks
Technical requirementsBenchmarking data insertion methodsBenchmarking data selection methodsBenchmarking data editing methodsBenchmarking data deletion methodsThe benchmarking results and their analysisSummaryQuestionsFurther reading
Chapter 12: Responsive User Interfaces
Technical requirementsBuilding a responsive UI with WinFormsEnabling DPI awareness and long file path awarenessAdding a splash screen that updates with loading progressAdding the increment count button and labelAdding a table with paged dataRunning long-running tasks in the backgroundBuilding a responsive UI with WPFBuilding a responsive UI with ASP.NETImplementing memory cachingImplementing distributed cachingUsing AJAX to update part of the currently displayed pageImplementing WebSocketsImplementing a real-time chat application using SignalRBuilding responsive UIs with .NET MAUILayoutsAccessibilityBlazorWebViewBuilding a responsive UI with MAUIBuilding a responsive UI with WinUI 3SummaryQuestionsFurther reading
Chapter 13: Distributed Systems
Technical requirementsImplementing the CQRS design patternImplementing event sourcingEvent sourcing example projectUsing Microsoft Azure for distributed systemsAzure FunctionsDurable Azure FunctionsContainers and serverlessManaging your cloud infrastructure with PulumiPerformance considerations for distributed computingSummaryQuestionsFurther reading
Part 3: Threading and Concurrency
Chapter 14: Multi-Threaded Programming
Technical requirementsUnderstanding threads and threadingCreating threads and using parametersPausing and interrupting threadsDestroying and canceling threadsScheduling threadsThread synchronization and lockingSummaryQuestionsFurther reading
Chapter 15: Parallel Programming
Technical requirementsUsing the Task Parallel Library (TPL)Using Parallel LINQ (PLINQ)Programming parallel data structuresBenchmarking with BenchmarkDotNetUsing lambda expressions with TPL and LINQParallel debugging and profiling toolsThe Parallel Stacks windowThe Tasks windowThe Concurrency VisualizerSummaryQuestionsFurther reading
Chapter 16: Asynchronous Programming
Technical requirementsUnderstanding the TAP modelNaming, parameters, and return typesInitiating asynchronous operationsExceptionsOptional cancellationOptional Progress Reportingasync, await, and TaskBenchmarking GetAwaiter.GetResult(), .Result, and .Wait for both Task and ValueTaskUsing async, await, and WhenAllCanceling asynchronous operationsWriting files asynchronouslyReading files asynchronouslySummaryQuestionsFurther reading
Assessments
Chapter 1, Introducing C# 10.0 and .NET 6Chapter 2, Implementing C# InteroperabilityChapter 3, Predefined Data Types and Memory AllocationsChapter 4, Memory ManagementChapter 5, Application Profiling and TracingChapter 6, The .NET CollectionsChapter 7, LINQ PerformanceChapter 8, File and Stream I/OChapter 9, Enhancing the Performance of Networked ApplicationsChapter 10, Setting Up Our Database ProjectChapter 11, Benchmarking Relational Data Access FrameworksChapter 12, Responsive User InterfacesChapter 13, Distributed Systems Chapter 14, Multi-Threaded ProgrammingChapter 15, Parallel ProgrammingChapter 16, Asynchronous Programming
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from High-Performance Programming in C# and .NET

Part 2: Writing High-Performance Code

Part 2 covers putting the framework to work by programming high-performance code. We start by looking at collections. Then we move on to look at LINQ performance, followed by files and streams. Next, we look at networking followed by working with data. After that, we learn how to keep user interfaces active during long operations. Then we finish up by looking at distributed systems that scale.

This part contains the following chapters:

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 ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Hands-On Network Programming with C# and .NET Core

Publisher Resources

ISBN: 9781800564718

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

High-Performance Programming in C# and .NET

by Jason Alls

Part 2: Writing High-Performance Code

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.