book

Clean Code with C# - Second Edition

Name: Clean Code with C# - Second Edition
Author: Jason Alls
ISBN: 9781837635191

by Jason Alls

December 2023

Intermediate to advanced

492 pages

12h 40m

English

Packt Publishing

Read now

Unlock full access

Clean Code with C#
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Chapter 1: Coding Standards and Principles in C#
Technical requirementsGood code versus bad codeThe need for coding standards, principles, and methodologiesCoding standardsCoding principlesCoding methodologiesSummaryQuestionsFurther reading
Chapter 2: Code Review – Process and Importance
A brief introduction to GitHubWhat is GitHub?GitHub’s use within the code review processResources for learningThe code review processPreparing code for reviewLeading a code reviewIssuing a pull requestResponding to a pull requestEffects of feedback on revieweesKnowing what to reviewThe company’s coding guidelines and business requirement(s)Naming conventionsFormattingTestingDocumentationArchitectural guidelines and design patternsPerformance and securityKnowing when to send code for reviewProviding and responding to review feedbackProviding feedback as a reviewerResponding to feedback as a revieweeSummaryQuestionsFurther reading
Chapter 3: Classes, Objects, and Data Structures
Technical requirementsOrganizing classesA class should have only one responsibilityClass organizationCommenting for documentation generationCohesion and couplingTight couplingLow couplingLow cohesionHigh cohesionDesigning for changeInterface-oriented programmingDependency injection and inversion of controlThe Law of DemeterA good and a bad example (chaining) of the Law of DemeterImmutable objects and data structuresUsing records to create immutable objectsObjects should hide data and expose methodsAn example of encapsulationData structures should expose data and have no methodsThe SOLID software methodologySRPOpen/closed principle (OCP)Liskov substitution principle (LSP)Interface segregation principle (ISP)Dependency inversion principle (DIP)SummaryQuestionsFurther reading
Chapter 4: Writing Clean Functions
Technical requirementsUnderstanding the difference between OOP and FPExplanation of the differencesUnderstanding why FP can lead to cleaner functionsUnclean methods and how they affect softwareFP and clean methodsFP examplesKeeping methods smallIndenting codeBreaking out of loopsAvoiding duplicationAvoiding multiple parametersImplementing the SRPHandling exceptions in FPAdding comments for readabilityXML documentation commentsInline commentsVariable declaration and memory managementDeclaring variables close to their usageDisposing of resourcesApplying security in methods, especially in APIsInput validationAuthentication and authorizationProtecting sensitive dataSummaryQuestionsFurther reading
Chapter 5: Exception Handling
Technical requirementsOverview of exception handling in C#try-catchtry-catch-finallyClean code exception-handling principlesSRPOCPDIPBest practices for handling exceptionsHandling the TPL AggregateException exceptionUse await with try-catch inside async methodsFlatten the exception hierarchyHandle individual exceptionsHandle exceptions as they occurCreating custom exceptions and when to use themAvoiding common mistakes in exception handlingTesting exception handlingUnit testing exception handlingIntegration testing exception handlingEnd-to-end testing exception handlingAn employee management example of mocking and unit testing with correct exception handlingSummaryQuestionsFurther reading
Chapter 6: Unit Testing
Technical requirementsUnderstanding unit testingWriting testable codeTDDAn example of using the AAA TDD patternChoosing a testing frameworkTesting framework attribute differencesTDD using MSTestTDD using NUnitTDD using xUnitRunning tests in Visual StudioWriting effective unit testsUsing code coverage analysis in Visual Studio 2022Ensuring your unit tests themselves are correctUsing stubs in place of mocksMocking dataIntegrating tests into the continuous integration and deployment (CI/CD) pipelineIntegrating tests into an Azure DevOps CI/CD pipelineProblem testsSummaryQuestionsFurther reading
Chapter 7: Designing and Developing APIs
Technical requirementsWhat is an API?APIs help different consumers build loosely coupled applicationsIdempotent and non-idempotent operationsHTTP verbsImportant API design topics you must considerHow can clean code help API design and development?The API design processAPI security risks and their mitigationsOn-premises APIs versus cloud APIsAPI development in C#Web API security with OWASPImportance of OWASP adherence in C# API developmentCreating an OWASP-compliant APIImplementing OWASP-compliant two-factor authentication (2FA)OpenID Connect (OIDC) and OAuth 2.0 (OAuth2)SummaryQuestionsFurther reading
Chapter 8: Addressing Cross-Cutting Concerns
A definition of cross-cutting concernsImportance and impact on software developmentCommon examples of cross-cutting concernsLoggingError handling and exception managementCachingPerformance optimizationTransaction managementValidationAuditing and complianceLocalization and internationalizationLogging and monitoringSummaryQuestionsFurther reading

Chapter 9: AOP with PostSharp
Technical requirementsAOPAOP frameworksHow AOP works with PostSharpExtending the aspect frameworkProject – Cross-cutting concerns reusable libraryAdding a caching concernAdding file logging capabilitiesAdding an exception-handling concernAdding a security concernAdding a validation concernAdding a transaction concernAdding a resource pool concernAdding a configuration settings concernAdding an instrumentation concernPostSharp and build pipeline considerationsDynamic AOP with Castle.DynamicProxySummaryQuestionsFurther reading
Chapter 10: Using Tools to Improve Code Quality
Technical requirementsCode analysisUsing quick actionsUsing the JetBrains dotTrace profilerUsing JetBrains ReSharperUsing Telerik JustDecompileContinuous integration with GitHub Actions and CodeQLSummaryQuestionsFurther reading
Chapter 11: Refactoring C# Code
Technical requirementsApplication-level code smellsBoolean blindnessCombinatorial explosionContrived complexityData clumpDeodorant commentsDuplicate codeLost intentThe mutation of variablesThe oddball solutionShotgun surgerySolution sprawlUncontrolled side effectsClass-level code smellsCyclomatic complexityDivergent changeDowncastingExcessive literal useFeature envyInappropriate intimacyIndecent exposureThe large class (the God object)The lazy class (the freeloader and the lazy object)The middleman classThe orphan class of variables and constantsPrimitive obsessionRefused bequestSpeculative generalityTell, Don’t AskTemporary fieldsMethod-level smellsThe black sheep methodCyclomatic complexityContrived complexityDead codeExcessive data returnFeature envyIdentifier sizeInappropriate intimacyLong lines (God lines)Lazy methodsLong methods (God methods)Long parameter lists (too many parameters)Message chainsThe middleman methodOddball solutionsSpeculative generalitySummaryQuestionsFurther reading
Chapter 12: Functional Programming
Technical requirementsImperative versus functional programmingImperative programmingKey differencesOverview of functional programming in C#First-class functions and Lambda expressionsLambda expressions in C#Higher-order functionsImmutability and pure functionsFunctional compositionUsing Lambda expressionsUsing LINQ and extension methodsUsing higher-order functionsOption types and the Maybe monadUsage of option types in C#The Maybe monad in C#Functional error handlingOption typesThe Maybe monadThe Either monadResult objectsFunctional data transformation and pipelinesLazy evaluationPattern matchingCurrying and partial applicationCurryingPartial applicationKey differencesConcurrency with functional programmingRecursionSummaryQuestionsFurther reading
Chapter 13: Cross-Platform Application Development with MAUI
Technical requirementsProject overviewWindows versionAndroid versionCreating the projectUnderstanding XAML structureThe MVVM patternAdding CommunityToolkit.MvvmThe modelsThe ViewModelsThe viewsConfiguring our to-do applicationSummaryQuestionsFurther reading
Chapter 14: Microservices
What are microservices?The downsides of microservices, some gotchas experienced by microservices, and how they can be overcome and avoidedComparison between microservices and monolithsThe design process for building successful microservicesThe application life cycle management (ALM) of microservicesMicroservice architecture patternsService registration and discoveryService discoveryService registrationContainerization and orchestration of microservicesContainerizationOrchestrationServerlessAPI gatewaysEvent-driven communicationService resilience and fault toleranceService monitoring and observabilityService monitoringObservabilitySecurityCI/CDMicroservice testingScaling microservicesVersioning and compatibilityMicroservices best practices and anti-patternsMicroservices best practicesMicroservices anti-patternsCase studies and real-world examplesSummaryQuestionsFurther reading
Assessments
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12Chapter 13Chapter 14
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Content preview from Clean Code with C# - Second Edition

4 Writing Clean Functions

Clean functions are methods that are small (they have two or fewer arguments) and avoid duplication. The ideal method has no parameters and does not modify the program’s state. Small methods are less prone to exceptions, so you will be writing much more robust code that benefits you in the long run as you will have fewer bugs to fix.

Functional programming (FP) is a software coding methodology that treats computations as the mathematical evaluation of computations. This chapter will teach you the benefits of treating computations as the evaluation of mathematical functions in order to void changing an object’s state.

Large methods (also known as functions) can be unwieldy to read and prone to errors, so writing small ...

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

Software Architecture with C# 12 and .NET 8 - Fourth Edition

Publisher Resources

ISBN: 9781837635191

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Clean Code with C# - Second Edition

by Jason Alls

4

Writing Clean Functions

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.