book

Tools and Skills for .NET 8

Name: Tools and Skills for .NET 8
Author: Mark J. Price
ISBN: 9781837635207

by Mark J. Price

July 2024

Intermediate to advanced

778 pages

20h 22m

English

Packt Publishing

Read now

Unlock full access

Preface
Where to find the code solutionsWhat this book coversWhat you need for this bookGet in touch
Introducing Tools and Skills for .NET
Introducing this book and its contentsCompanion books to complete your learning journeyAudiences for this bookToolsSkillsTestingDesign and career developmentSetting up your development environmentChoosing the appropriate tool and application type for learningUsing Visual Studio for general developmentUsing Code for cross-platform developmentUsing GitHub Codespaces for development in the cloudUsing Rider for cross-platform developmentWhat I usedDeploying cross-platformDownloading and installing Visual StudioVisual Studio keyboard shortcutsVisual Studio Enterprise edition toolsDownloading and installing CodeInstalling other extensionsManaging Code extensions at the command promptUnderstanding Code versionsCode keyboard shortcutsDownloading and installing RiderOther JetBrains toolsChrome AI toolsMaking good use of the GitHub repository for this bookRaising issues with the bookGiving me feedbackDownloading solution code from the GitHub repositoryWhere to go for helpReading documentation on Microsoft LearnGetting help for the dotnet toolLLMs like ChatGPTGetting better help from LLMs using prompt engineeringAI usage by developersGetting help on Discord and other chat forumsSetting up a database and projects for this bookUsing a sample relational databaseSetting up SQL Server and the Northwind databaseCreating the Northwind database for a local SQL ServerCreating the Northwind database for SQL Edge in DockerCreating a class library for entity models using SQL ServerCreating a class library for the data context using SQL ServerCreating a test project to check the integration of the class librariesRunning testsUsing .NET 9 with this bookPracticing and exploringExercise 1.1 – Online-only materialExercise 1.2 – Practice exercisesExercise 1.3 – Test your knowledgeExercise 1.4 – Explore topicsSummaryJoin our book’s Discord space
Making the Most of the Tools in Your Code Editor
Introducing common tools and featuresRefactoring featuresCode snippetsEditor configurationAI companionsTools in Visual Studio 2022Refactoring featuresAdd method parameter checksMethod parameter refactoringConvert foreach to for and vice versaSimplify LINQ statementsAlign code elementsRefactor to primary constructorsCode snippetsCode snippets schemaCreating and importing code snippetsDistributing code snippetsEditor configurationAI companions: GitHub CopilotMaking the most of GitHub CopilotNavigating Visual StudioCopying and pasting a statementSwitching between file tabs and tool windowsFeatures to improve the editing experienceLine numbers and word wrapKeyboard shortcutsFormatting codeTask listExtension ManagerTools in Visual Studio CodeRefactoring featuresCode snippetsDecompiling .NET assembliesCreating a console app to decompileDecompiling using the ILSpy extension for Visual StudioViewing source links with Visual StudioNo, you cannot technically prevent decompilationLowering C# codeCustom project and item templatesCreating a project for a templateTesting the project templatePracticing and exploringExercise 2.1 – Online-only materialExercise 2.2 – Practice exercisesExercise 2.3 – Test your knowledgeExercise 2.4 – Explore topicsSummaryJoin our book’s Discord space
Source Code Management Using Git
Introducing source code managementFeatures of source code managementTypes of SCM systemCommon SCM systemsIntroducing GitFeatures of GitWhy is Git hard to learn?Roles in a team for GitDownloading the latest GitGit integration with Visual StudioConfiguring your Git identityConfiguring SSH signature enforcementConfiguring your default branchGetting help for GitWorking with GitStarting with a Git repositoryCreating and adding files to a Git repository in theoryTracking changes in GitCreating a Git repository in practiceCreating a new projectCommitting filesUndoing a commitCleaning a commitStashingIgnoring filesReviewing Git repositoriesViewing differences in filesViewing your commit historyFiltering log outputManaging remote repositoriesBranching and mergingWalking through a branching and merging exampleDeleting and listing branchesSummary of common Git commandsPracticing and exploringExercise 3.1 – Online-only materialExercise 3.2 – Practice exercisesExercise 3.3 – Test your knowledgeExercise 3.4 – Explore topicsSummaryJoin our book’s Discord space
Debugging and Memory Troubleshooting
Debugging strategiesIntroducing debugging strategiesUnderstanding the problemHow to start debuggingWhen to give up debuggingInteractive debugging with Visual StudioCreating code with objects to viewSetting a breakpoint and starting debuggingNavigating with the debugging toolbarDebugging windowsControlling what appears in debug panesDebugging test projectsAsking GitHub Copilot Chat for debugging helpUnderstanding stack and heap memoryHow reference and value types are stored in memoryUnderstanding unsafe codeUnderstanding pointersOther uses of pointersUnderstanding boxingUnderstanding garbage collectionControlling the GCManaging resources with IDisposableTools and skills for memory troubleshootingCommon memory tools and skillsVisual Studio toolsUsing Visual Studio Memory UsagePracticing and exploringExercise 4.1 – Online-only materialExercise 4.2 – Practice exercisesExercise 4.3 – Test your knowledgeExercise 4.4 – Explore topicsSummaryJoin our book’s Discord space
Logging, Tracing, and Metrics for Observability
Logging and tracing in .NETUnderstanding ILogger in .NETHow to log using ILoggerBuilding a web service for loggingTesting the basic functionality of the web serviceMonitoring with metrics in .NETConcepts for metrics and alertsMetricsAlertsScenarios for metrics and alertsImplementing metricsAdding metrics to an ASP.NET Core projectViewing metricsIntroducing OpenTelemetrySupported instrumentation packagesInstrumenting an ASP.NET Core projectViewing the telemetryPracticing and exploringExercise 5.1 – Online-only materialExercise 5.2 – Practice exercisesExercise 5.3 – Test your knowledgeExercise 5.4 – Explore topicsSummaryJoin our book’s Discord space
Documenting Your Code, APIs, and Services
Introducing documentationBenefits of documentationWhen not to documentDocumenting your source codeWhen should you document your source code?Good practices for commenting your source codeDocumenting public APIs in class librariesXML comment documentationHow to document code using XML commentsGenerating documentation using DocFXCreating a DocFX projectAdding custom documentation contentMarkdown markup languageHeadingsFormatting textCreating listsLinks and imagesCode blocks and syntax highlightingTablesDocumenting servicesConsiderations for documenting servicesTools for documenting servicesUnderstanding the OpenAPI Specification (OAS)Documenting a Minimal APIs service using OpenAPIDocumenting visually with Mermaid diagramsRendering Mermaid diagramsFlowcharts using MermaidClass diagrams using MermaidConverting Mermaid to SVGPracticing and exploringExercise 6.1 – Online-only materialExercise 6.2 – Practice exercisesExercise 6.3 – Test your knowledgeExercise 6.4 – Explore topicsSummaryJoin our book’s Discord space
Observing and Modifying Code Execution Dynamically
Working with reflection and attributesMetadata in .NET assembliesVersioning of assembliesReading assembly metadataCreating custom attributesUnderstanding compiler-generated types and membersMaking a type or member obsoleteDynamically loading assemblies and executing methodsA warning about reflection and native AOTReflection improvements in .NET 9Doing more with reflectionWorking with expression treesUnderstanding components of expression treesExecuting the simplest expression treeCreating source generatorsImplementing the simplest source generatorPracticing and exploringExercise 7.1 – Online-only materialExercise 7.2 – Practice exercisesExercise 7.3 – Test your knowledgeExercise 7.4 – Explore topicsSummaryJoin our book’s Discord space
Protecting Data and Apps Using Cryptography
Understanding the vocabulary of protectionTechniques to protect your dataKeys and key sizesIVs and block sizesSaltsGenerating keys and IVsEncrypting and decrypting dataEncrypting symmetrically with AESHashing dataHashing with the commonly used SHA-256Signing dataSigning with SHA-256 and RSAGenerating random numbers for cryptographyAuthenticating and authorizing usersAuthentication and authorization mechanismsIdentifying a userUser membershipImplementing authentication and authorizationProtecting application functionalityReal-world authentication and authorizationWhat’s coming in .NET 9CryptographicOperations.HashData() methodKMAC algorithmPracticing and exploringExercise 8.1 – Online-only materialExercise 8.2 – Practice exercisesExercise 8.3 – Test your knowledgeExercise 8.4 – Explore topicsSummaryJoin our book’s Discord space
Building an LLM-Based Chat Service
Introducing LLMsHow LLMs workObtaining access to an LLMUsing Semantic Kernel with an OpenAI modelUnderstanding Semantic KernelUnderstanding functionsAdding functionsAdding session memory and enabling multiple functionsStreaming resultsAdding logging and resilienceRunning local LLMsHugging FaceOllamaOllama modelsOllama CLIOllamaSharp .NET packageLM StudioPracticing and exploringExercise 9.1 – Online-only materialExercise 9.2 – Practice exercisesExercise 9.3 – Test your knowledgeExercise 9.4 – Explore topicsSummaryJoin our book’s Discord space

Dependency Injection, Containers, and Service Lifetime
Introducing dependency injectionWhy use DI?The mechanisms of DI in .NETExamples in modern .NETConstructor injection exampleProperty injection examplesMethod injection exampleRegistering dependency service lifetimesRegistering multiple implementationsWhen are exceptions thrown?Best practices for DIImplementing .NET Generic HostKey features of the .NET Generic HostBuilding a .NET Generic HostUnderstanding host services and eventsService registration methodsDependency graphs and service resolutionDisposing servicesDI with ASP.NET CoreRegistering services for features using extension methodsWhen you cannot use constructor injectionUsing scoped services in middlewareResolving services at startupDI and viewsDI, action methods, and Minimal APIsPracticing and exploringExercise 10.1 – Online-only materialExercise 10.2 – Practice exercisesExercise 10.3 – Test your knowledgeExercise 10.4 – Explore topicsSummaryJoin our book’s Discord space
Unit Testing and Mocking
Introducing all types of testingUnit testingIntegration, end-to-end, and security testingPerformance, load, and stress testingFunctional and usability testingTesting terminologyAttributes of all good testsTest outcomesTest doubles, mocks, and stubsAdopting a testing mindsetPros and cons of test-driven developmentCore principles of TDDPros of TDDCons of TDDGood practices for TDDUnit testingHow isolated should unit tests be?Naming unit testsUnit testing using xUnitCommon xUnit attributesCreating a SUTWriting simple unit testsTest methods with parametersTesting theory methods using InlineDataTesting theory methods using ClassDataTesting theory methods using strongly typed ClassDataTesting theory methods using MethodDataPositive and negative test resultsRed flags in unit testsSeeing output during test executionSet up and tear downControlling test fixturesMocking in testsLibraries for mockingUsing NSubstitute to create test doublesMocking with NSubstitute exampleMaking fluent assertions in unit testingMaking assertions about stringsMaking assertions about collections and arraysMaking assertions about dates and timesGenerating fake data with BogusFaking data test projectWriting a method with fake dataPracticing and exploringExercise 11.1 – Online-only materialExercise 11.2 – Practice exercisesExercise 11.3 – Test your knowledgeExercise 11.4 – Explore topicsSummaryJoin our book’s Discord space
Integration and Security Testing
Basics of integration testingWhich external systems to testSharing fixtures in integration testsWalkthrough of an example integration testIntegration testing with data storesDeveloper instances of the database and migrationsData lifecycleTesting services using dev tunnelsInstalling the dev tunnel CLIExploring a dev tunnel with the CLI and an echo serviceExploring a dev tunnel with an ASP.NET Core projectIntroducing security testingOpen Web Application Security ProjectOWASP Top 10A1:2021 – Broken Access ControlA2:2021 – Cryptographic FailuresA3:2021 – InjectionA4:2021 – Insecure DesignA5:2021 – Security MisconfigurationA6:2021 – Vulnerable and Outdated ComponentsA7:2021 – Identification and Authentication FailuresA8:2021 – Software and Data Integrity FailuresA9:2021 – Security Logging and Monitoring FailuresA10:2021 – Server-Side Request Forgery (SSRF)OWASP Top 10 summaryThreat modelingMicrosoft Threat Modeling ToolSecurity Development Lifecycle (SDL)OWASP resourcesAzure Security and Compliance Blueprints.NET security best practicesPracticing and exploringExercise 12.1 – Online-only materialExercise 12.2 – Practice exercisesExercise 12.3 – Test your knowledgeExercise 12.4 – Explore topicsSummaryJoin our book’s Discord space
Benchmarking Performance, Load, and Stress Testing
Benchmarking performanceImportance of a baselineBig O notationStatistical metricsBenchmarkDotNet for benchmarking performanceAvoiding benchmarking mistakesIsolating benchmarking code from setup or teardownTrust the toolCompare like to likeBeware of environmental variationsIdentifying poor blog posts about performanceLoad and stress testingApache JMeterBombardier – a fast cross-platform HTTP benchmarking toolUsing BombardierDownloading BombardierComparing an AOT and a non-AOT web serviceTesting the two web services with BombardierInterpreting Bombardier resultsNBomber – a load testing frameworkNBomber scenariosLoad simulationsNBomber typesNBomber project examplePracticing and exploringExercise 13.1 – Online-only materialBenchmarking mistakesExercise 13.2 – Practice exercisesExercise 13.3 – Test your knowledgeExercise 13.4 – Explore topicsSummaryJoin our book’s Discord space
Functional and End-to-End Testing of Websites and Services
Understanding functional and end-to-end testingExample 1: Testing a Web API serviceExample 2: Testing an ASP.NET Core websiteExample 3: Testing a SignalR real-time applicationTesting web user interfaces using PlaywrightBenefits for .NET developersAlternatives to PlaywrightCommon Playwright testing typesCommon Playwright testing methodsCommon Playwright locator methodsCommon Playwright locator automation methodsTesting common scenarios with eShopOnWebPage navigation and title verificationInteracting with a web user interfaceSelecting dropdown items and clicking elementsForm submission, authentication, and validationResponsive design testingEmulating screen sizesEmulating devicesEmulating locale, time zone, and geolocationEmulating dark mode and color schemesEmulating the user agent, disabling JavaScript, and going offlineSingle-Page Applications (SPAs) and dynamic contentGenerating tests with the Playwright InspectorTesting web services using xUnitCreating a web service ready for testingCreating the test projectPracticing and exploringExercise 14.1 – Online-only materialExercise 14.2 – Practice exercisesExercise 14.3 – Test your knowledgeExercise 14.4 – Explore topicsSummaryJoin our book’s Discord space
Containerization Using Docker
Introducing containerizationHow containers work and their benefitsDocker, Kubernetes, and .NET AspireKubernetes.NET AspireContainer registriesDocker conceptsDocker tools and technologiesDocker command-line interface (CLI) commandsBuilding images using DockerfilesConfiguring ports and running a containerInteractive modeSetting environment variablesCommon Docker container images.NET container imagesCVEs and Chiseled UbuntuManaging containers with DockerInstalling Docker and using prebuilt imagesDocker image hierarchy and layersContainerizing your own .NET projectsContainerizing a console app projectPublishing to a Docker containerContainerizing an ASP.NET Core projectWorking with test containersHow Testcontainers for .NET worksUsage examplePracticing and exploringExercise 15.1 – Online-only materialExercise 15.2 – Practice exercisesExercise 15.3 – Test your knowledgeExercise 15.4 – Explore topicsSummaryJoin our book’s Discord space
Cloud-Native Development Using .NET Aspire
Introducing AspireWhat does the Aspire team say?Code editor and CLI support for AspireStarting an Aspire solutionAspire project typesAspire resource typesAspire application model and orchestrationAspire project templatesExploring the Aspire starter templateCreating the Aspire starter applicationExploring the Aspire starter solutionDeeper into AspireDeveloper dashboard for monitoringAppHost project for orchestrating resourcesServiceDefaults project for centralized configurationParticipating functional projectsConfiguring RedisAspire componentsLogging, tracing, and metrics for observabilityDocker versus Podman for containersWaiting for containers to be readyWhat about Dapr, Orleans, and Project Tye?DaprOrleansProject TyeChoosing between Dapr, Orleans, and AspireAspire for new and existing solutionsCreating a new Aspire solutionAspire and PostgreSQLUsing data volumes and configuring a stable passwordAdding Aspire to an existing solutionSwitching to Aspire componentsReviewing the eShop reference applicationDeployment with AspirePracticing and exploringExercise 16.1 – Online-only materialExercise 16.2 – Practice exercisesExercise 16.3 – Test your knowledgeExercise 16.4 – Explore topicsSummaryJoin our book’s Discord space
Design Patterns and Principles
SOLID principlesSingle Responsibility Principle (SRP)SRP exampleSRP violating exampleSRP adhering refactoringSRP common mistakesSRP takeawaysOpen/Closed Principle (OCP)OCP exampleOCP violating exampleOCP common mistakesOCP takeawaysLiskov Substitution Principle (LSP)LSP exampleLSP violating exampleLSP adhering refactoringLSP common mistakesLSP in .NETLSP takeawaysInterface Segregation Principle (ISP)ISP exampleISP violating exampleISP adhering refactoringISP common mistakesISP in .NETISP takeawaysDependency Inversion Principle (DIP)DIP exampleDIP violating exampleDIP common mistakesDIP takeawaysDesign patternsCreational patternsBuilder patternStructural design patternsAdapter a.k.a. the Wrapper patternBehavioral design patternsTemplate Method patternDesign principlesDRYKISSYAGNILaw of DemeterLoD exampleLoD takeawaysComposition over InheritanceComposition over Inheritance exampleComposition over Inheritance violating exampleComposition over Inheritance takeawaysPrinciple of Least AstonishmentPoLA examplePoLA takeawaysAlgorithms and data structuresSorting algorithmsSearching algorithmsData structure algorithmsHashing algorithmsRecursive algorithmsWhere to learn more about algorithms and data structuresPracticing and exploringExercise 17.1 – Online-only materialExercise 17.2 – Practice exercisesExercise 17.3 – Test your knowledgeExercise 17.4 – Explore topicsSummaryJoin our book’s Discord space
Software and Solution Architecture Foundations
Introducing software and solution architectureSoftware architectureSolution architectureSoftware architecture conceptsDomain-Driven Design (DDD)Software Development Lifecycle (SDLC) methodologiesSoftware architecture stylesCommand Query Responsibility Segregation (CQRS)Solution architecture conceptsConclusionUncle Bob’s Clean ArchitectureClean architecture conceptsDefining entitiesDefining use cases and business rulesImplementing interfacesImplementing presentersImplementing controllersGood practices in .NET Clean ArchitectureDiagramming design using MermaidMermaid for software and solution architectureMermaid diagram typesMermaid flowchartsFlowchart syntaxExample flowchart – a user login processExample flowchart – a software development processSequence diagram syntaxExample sequence diagram – a user registration processExample sequence diagram – website querying a databasePracticing and exploringExercise 18.1 – Online-only materialExercise 18.2 – Practice exercisesExercise 18.3 – Test your knowledgeExercise 18.4 – Explore topicsSummaryJoin our book’s Discord space
Your Career, Teamwork, and Interviews
Working on a development teamBeing a software engineerCareer pathRoles on a development team that you will collaborate withProject managerBusiness analystQuality assurance analyst or testerUser experience designerDatabase administratorDevOps engineerFront-end (FE) developerTechnical lead or architectOnboarding processHow to ask for training and developmentIdentify specific training needsAlign training with business goalsPrepare a cost-benefit analysisPropose a flexible planRequest a meeting and present your casePair programmingCould an LLM replace a human paired programmer?Applying for a jobBefore you applyRefine your skills and knowledgeObtain certificationsSearch for job openingsCraft your job application, resume, and online profilesYour resume or curriculum vitaeAsk an LLM to improve your resumeInterview preparationDo not use an LLM during an interviewInterviewing at the big companiesApplying for more experienced positionsApplying for tester positionsSelection of questionsBehavioral questionsSTAR methodUsing the STAR method effectivelyTips during interviewsHow to handle difficult coding questionsHow to handle unprepared interviewersWhat to never doSample interview questions1. .NET CLI toolsGood answerCommonly given poor answer2. Git fundamentalsGood answerCommonly given poor answer3. Entity Framework CoreGood answerCommonly given poor answer4. Interfaces and abstract classes5. Properties and indexers6. Generics7. Delegates and events8. Language Integrated Query (LINQ)9. Asynchronous programming with async and await10. Memory management and garbage collection11. Differences between modern .NET and .NET Framework12. Cross-platform capabilities13. .NET Standard14. Dependency injection in .NET15. Middleware in ASP.NET Core16. Configuration and Options pattern17. Hosting and Kestrel server18. Data types19. Globalization and localization20. Control structures21. Exception handling22. Git branching strategies23. Code reviews and pair programming24. Agile and Scrum methodologies25. Documentation standards26. Problem-solving skills27. Project management tools28. Estimation techniques29. Team collaboration30. Leadership and mentorship31. MVC pattern32. Razor syntax33. Web API development34. RESTful services best practices35. SignalR for real-time web functionality36. State management37. Authentication and authorization38. Blazor WebAssembly39. Benefits of microservices40. Challenges in microservices architecture41. Docker containers and .NET42. Microservices communication patterns43. Resilience and transient fault handling44. Distributed tracing45. Health checks and monitoring46. AutoMapper vs. extension method vs. implicit operator47. ADO.NET fundamentals48. Entity Framework Core performance tuning49. Unit testing frameworks like xUnit50. Mocking frameworks like NSubstitute51. Integration testing strategies52. Performance testing53. Security testing54. Automated UI testing55. SOLID principles56. Singleton pattern57. Factory pattern58. Memory leak identification59. Development methodologies60. Big OWhen you’re failing, you’re learningPracticing and exploringExercise 19.1 – Online-only materialExercise 19.2 – Practice exercisesExercise 19.3 – Test your knowledgeExercise 19.4 – Explore topicsSummaryJoin our book’s Discord space
Epilogue
Next steps on your .NET learning journeyCompanion books to continue your learning journeyNinth edition of C# 12 and .NET 8 coming soon for .NET 9Planned .NET 10 trilogyPackt books to take your learning furtherGood luck!
Index

Content preview from Tools and Skills for .NET 8

7 Observing and Modifying Code Execution Dynamically

This chapter is about some common types that are included with .NET for performing code reflection and applying and reading attributes, working with expression trees, and creating source generators. These technologies enable a broad range of capabilities from code inspection and modification to runtime behavior alteration. This can significantly enhance the flexibility and efficiency of your applications.

Reflection is a powerful feature in .NET that allows programs to inspect and manipulate themselves. It can be used to access information about assemblies, modules, and types, and to dynamically create and invoke types and methods.

Expression trees represent code in a tree-like data structure, ...

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

Tools and Skills for .NET 10 - Second Edition

Publisher Resources

ISBN: 9781837635207

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Tools and Skills for .NET 8

by Mark J. Price

7

Observing and Modifying Code Execution Dynamically

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.