book

Clean Code in C#

Name: Clean Code in C#
Author: Jason Alls
ISBN: 9781838982973

by Jason Alls

July 2020

Intermediate to advanced

500 pages

11h 8m

English

Packt Publishing

Read now

Unlock full access

Title Page
Copyright and Credits
Clean Code in C#
Dedication
About Packt
Why subscribe?
Contributors
About the authorAbout the reviewerPackt is searching for authors like you
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 touchReviews
Coding Standards and Principles in C#
Technical requirementsGood code versus bad codeBad codeImproper indentationComments that state the obviousComments that excuse bad codeCommented-out lines of codeImproper organization of namespacesBad naming conventionsClasses that do multiple jobsMethods that do many thingsMethods with more than 10 lines of codeMethods with more than two parametersUsing exceptions to control program flowCode that is difficult to readCode that is tightly coupledLow cohesionObjects left hanging aroundUse of the Finalize() methodOver-engineeringLearn to Keep It Simple, StupidLack of regions in large classesLost-intention codeDirectly exposing informationGood codeProper indentationMeaningful commentsAPI documentation commentsProper organization using namespacesGood naming conventionsClasses that only do one jobMethods that do one thingMethods with less than 10 lines, and preferably no more than 4Methods with no more than two parametersProper use of exceptionsCode that is readableCode that is loosely coupledHigh cohesionObjects are cleanly disposed ofAvoiding the Finalize() methodThe right level of abstractionUsing regions in large classesThe need for coding standards, principles, and methodologiesCoding standardsCoding principlesCoding methodologiesCoding conventionsModularityKISSYAGNIDRYSOLIDOccam's RazorSummaryQuestionsFurther reading
Code Review – Process and Importance
The code review processPreparing code for reviewLeading a code reviewIssuing a pull requestResponding to a pull requestEffects of feedback on revieweesKnowing what to reviewCompany's coding guidelines and business requirement(s)Naming conventionsFormattingTestingArchitectural 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
Classes, Objects, and Data Structures
Technical requirementsOrganizing classes A class should have only one responsibilityCommenting for documentation generationCohesion and couplingAn example of tight couplingAn example of low couplingAn example of low cohesionAn example of high cohesionDesign for changeInterface-oriented programmingDependency injection and inversion of controlAn example of DIAn example of IoCThe Law of Demeter A good and a bad example (chaining) of the Law of DemeterImmutable objects and data structuresAn example of an immutable typeObjects should hide data and expose methodsAn example of encapsulationData structures should expose data and have no methodsAn example of data structureSummaryQuestionsFurther reading
Writing Clean Functions
Understanding functional programmingKeeping methods smallIndenting codeAvoiding duplicationAvoiding multiple parametersImplementing SRPSummaryQuestionsFurther reading

Exception Handling
Checked and unchecked exceptionsAvoiding NullPointerExceptionsBusiness rule exceptionsExample 1 – handling conditions with business rule exceptionsExample 2 – handling conditions with normal program flowExceptions should provide meaningful informationBuilding your own custom exceptionsSummaryQuestionsFurther reading
Unit Testing
Technical RequirementsUnderstanding the reasons for a good testUnderstanding the testing toolsMSTestNUnitMoqSpecFlowTDD methodology practice – fail, pass, and refactorRemoving redundant tests, comments, and dead codeSummaryQuestionsFurther reading
End-to-End System Testing
E2E testingThe login module (subsystem)The admin module (subsystem)The test module (subsystem)Testing our three-module system using E2EFactoriesDependency injectionModularizationSummaryQuestionsFurther reading
Threading and Concurrency
Understanding the thread life cycleAdding thread parametersUsing a thread poolTask Parallel LibraryParallel.Invoke()Parallel.For()ThreadPool.QueueUserWorkItem()Using a mutex with synchronous threadsWorking with parallel threads using semaphoresLimiting the number of processors and threads in the thread poolPreventing deadlocksCoding a deadlock examplePreventing race conditionsUnderstanding static constructors and methods Adding static constructors to our sample codeAdding static methods to our sample codeMutability, immutability, and thread safetyWriting code that is mutable and not thread-safeWriting code that is immutable and thread-safe Understanding thread safetySynchronized method dependenciesUsing the Interlocked classGeneral recommendationsSummaryQuestionsFurther reading
Designing and Developing APIs
Technical requirementsWhat is an API?API proxiesAPI design guidelinesWell-defined software boundariesUnderstanding the importance of good quality API documentation Swagger API developmentPassing immutable structs instead of mutable objectsTesting third-party APIsTesting your own APIsAPI design using RAMLInstalling Atom and API Workbench by MuleSoftCreating the projectGenerating our C# API from our agnostic RAML design specificationSummaryQuestionsFurther reading
Securing APIs with API Keys and Azure Key Vault
Technical requirementsUndertaking the API project – dividend calendarAccessing the Morningstar APIStoring the Morningstar API key in Azure Key VaultCreating the dividend calendar ASP.NET Core web application in AzurePublishing our web applicationUsing an API key to secure our dividend calendar APISetting up the repositorySetting up authentication and authorizationAdding authenticationAdding authorizationTesting our API key securityAdding the dividend calendar codeThrottling our API SummaryQuestionsFurther reading
Addressing Cross-Cutting Concerns
Technical requirementsThe decorator patternThe proxy patternAOP with PostSharpExtending the aspect frameworkDeveloping our aspectInjecting behaviors before and after the method executionExtending the architectural frameworkProject – cross-cutting concerns reusable libraryAdding the caching concernAdding file logging capabilitiesAdding the logging concernAdding the exception-handling concernAdding the security concernAdding the validation concernAdding the transaction concernAdding the resource pool concernAdding the configuration settings concernAdding the instrumentation concernSummaryQuestionsFurther reading
Using Tools to Improve Code Quality
Technical requirementsDefining good-quality codePerforming code cleanup and calculating code metrics Performing code analysisUsing quick actionsUsing the JetBrains dotTrace profilerUsing JetBrains ReSharperUsing Telerik JustDecompileSummaryQuestionsFurther reading
Refactoring C# Code – Identifying Code Smells
Technical requirementsApplication-level code smellsBoolean blindnessCombinatorial explosionContrived complexityData clumpDeodorant comments Duplicate codeLost intentThe mutation of variablesThe oddball solutionShotgun surgerySolution sprawlUncontrolled side effectsClass-level code smellsCyclomatic complexityReplacing switch statements with the factory patternImproving the readability of conditional checks within an if statementDivergent changeDowncastingExcessive literal useFeature envyInappropriate intimacyIndecent exposureThe large class (aka the God object)The lazy class (aka 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 (aka God lines)Lazy methodsLong methods (aka God methods)Long parameter lists (aka too many parameters)Message chainsThe middleman methodOddball solutionsSpeculative generalitySummaryQuestionsFurther reading
Refactoring C# Code – Implementing Design Patterns
Technical requirementsImplementing creational design patternsImplementing the singleton patternImplementing the factory method patternImplementing the abstract factory patternImplementing the prototype patternImplementing the builder patternImplementing structural design patternsImplementing the bridge patternImplementing the composite patternImplementing the façade patternImplementing the flyweight patternOverview of behavioral design patternsFinal thoughtsSummaryQuestionsFurther reading
Assessments
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12Chapter 13Chapter 14
Other Books You May Enjoy
Leave a review - let other readers know what you think

Content preview from Clean Code in C#

Addressing Cross-Cutting Concerns

There are two types of concerns that you need to have when writing clean code—core concerns and cross-cutting concerns. Core concerns are the reasons for the software and why it is being developed. Cross-cutting concerns are the concerns that are not part of the business requirements and that form the core concerns, but must be addressed in all areas of the code, as illustrated in the following diagram:

It is the cross-cutting concerns that we will be covering in this chapter by building a reusable class library that you can modify or extend to your liking. Cross-cutting concerns include configuration management, ...

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

Publisher Resources

ISBN: 9781838982973

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Clean Code in C#

by Jason Alls

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.