Master the Art of Writing Clean Code in C

Master the Art of Writing Clean Code in C

What you’ll learn

Give best names for functions, variables and other API members
Understand and rely on programming metaprinciples such as DRY, YAGNI, KISS and others
Write clean functions
Detect common architectural smells and refactor the problems
Apply principles of functional programming
Apply Dependency Injection and avoid common DI-related smells
Write clean unit tests
Practice Test-Driven Development

Requirements

You should already be familiar with the basics of C#

Description

Learn how to design and implement types in C# so that the other developers won’t hate you when using one of the types developed by you. It means you are going to learn how to write code of the high quality: readable, understandable and reliable.
Improve your knowledge in object-oriented programming in the context of clean coding and building types of high quality.

Learn how to give the best names for API members Learn all the tricks related to writing clean functionsAvoid common architectural smells. Get rid of unpleasant smellsApply principles of functional programming: achieve immutability, remove side effects, extend typesAvoid smells related to dependency injectionWrite cleaner unit testsPractice Test-Driven DevelopmentFoundations of building object-oriented infrastructures
Despite the fact that C# is a very rich on features language, it’s very common to see poorly designed and implemented types in a real world. In fact, C# is one of the richest on features language among object-oriented languages in the world nowadays. But with great power comes great responsibility. It’s challenging  to use all those features in a right way.
You probably have already heard the following well-known statement: most code sucks. Well, this course is all about how to produce code which doesn’t suck.
Owning skills of producing a well-designed and well-implemented types is the prerequisite for the other developers to treat you as a real professional.
Content and Overview
This course is aimed at all the C# developers, from beginners to seniors. Topics which are covered in the course are relevant for all kinds of C# developers since all developers design and implement APIs. The topics complexity is very different. There are plenty of very simple topics, and at the same time, there are topics which require from you a solid C# background. There are plenty of code examples throughout this course, so you will learn both theoretical and practical material.
The course covers the following topics:

Meta Principles: DRY, KISS, YAGNI, SoC, CQS, PoLA, EncapsulationHow to give better names for API members and what naming conventions exist in the .NET platform and suited for C#Common problems encountered by C# developers in the process of designing and implementing APIs: classes vs structures, creational patterns vs constructors,  poor naming, excessively long methods, output parameters and so on.Common Architectural Design Smells such as Primitive Obsession, Hidden Dependencies, Violation of Law of Demeter and other.Functional Programming: immutability, temporal coupling, pipelining, extending IDisposable, Builder Design Pattern, abusing extension methods, dealing with errorsDI-related anti-patterns: control freak, hidden dependencies, temporal coupling, ambient context, facade service, bastard injection, cyclic dependenciesClean Unit Tests: singletons and static classes, excessive number of interfaces, testing trivial code, testing of a single concern, different best practicesPracticing TDD: definition, 3 laws, parsing roman numerals, continuous testing, implementing Tic-Tac-ToeThe list is far from being complete. The course covers a great number of topics. Enroll and start Mastering the Art of Writing Clean Code in C#!
————————————————————
Keywords related to the course:
C# Clean CodeC# Best PracticesAPI in C#Building API in C#Clean Code in C# tutorialRefactoring

Overview

Section 1: Before Taking the Course

Lecture 1 How to Ask Questions

Lecture 2 Download Source Code

Lecture 3 Join .NET Community of Students

Lecture 4 Motivation for Writing Clean Code

Section 2: Programming Metaprinciples

Lecture 5 Outline

Lecture 6 DRY – Don’t Repeat Yourself

Lecture 7 KISS – Keep it Simple, Stupid

Lecture 8 YAGNI – You Ain’t Gonna Need It

Lecture 9 Separation of Concerns (SoC)

Lecture 10 Command-Query Separation Principle (CQS)

Lecture 11 Principle of Least Astonishment

Lecture 12 Encapsulation and Information Hiding

Lecture 13 Conclusion

Section 3: Naming API Members

Lecture 14 Outline

Lecture 15 General Principles of Naming

Lecture 16 About Naming Once Again

Lecture 17 Naming Conventions in .NET

Lecture 18 Conclusion

Section 4: Writing Clean Functions

Lecture 19 Outline

Lecture 20 Variable Declaration on the Top

Lecture 21 Magic Numbers

Lecture 22 “Stringly” Typed Smell

Lecture 23 Property VS Method

Lecture 24 Implementing Parameters

Lecture 25 Too Many Parameters

Lecture 26 Too Long Methods

Lecture 27 Creational Patterns VS Constructors

Lecture 28 “Extract Method” Refactoring

Lecture 29 Simplifying Complex Logic

Lecture 30 Sequence of Arguments

Lecture 31 Guard Clauses and Early Returns

Lecture 32 Poor Conditional Clauses

Lecture 33 Output Parameters

Lecture 34 Comments

Lecture 35 Prefer Positive if-Statements

Lecture 36 Conclusion

Section 5: Common Architectural Design Smells

Lecture 37 Outline

Lecture 38 Primitives Obsession

Lecture 39 Violation of Law of Demeter

Lecture 40 Temporal Coupling

Lecture 41 Refactoring to “Template Method” Design Pattern

Lecture 42 Refactoring to “Strategy” Design Pattern

Lecture 43 Refactoring to “State” Design Pattern

Lecture 44 Conclusion

Section 6: Functional Programming: Extendibility and Immutability

Lecture 45 Outline

Lecture 46 Programming Paradigms

Lecture 47 Defining Functional Programming

Lecture 48 Functions, Functions, and Functions Again

Lecture 49 Why Functional Programming?

Lecture 50 Immutability. Intro

Lecture 51 Immutability of Structures

Lecture 52 Temporal Coupling and Immutability

Lecture 53 Pipelining

Lecture 54 Extending IDisposable

Lecture 55 General Extensions

Lecture 56 Extending StringBuilder

Lecture 57 Abusing Extension Methods

Lecture 58 Builder Design Pattern. Immutability and Testability

Lecture 59 Errors and Functional Programming

Lecture 60 Errors Handling: Pipelining by Method Chaining

Lecture 61 Conclusion

Section 7: DI-Related Anti-Patterns & Refactorings

Lecture 62 Outline

Lecture 63 Control Freak

Lecture 64 Hidden Dependencies and Service Locator

Lecture 65 Temporal Coupling and Constructor Injection

Lecture 66 Constructor Over-Injection

Lecture 67 Ambient Context

Lecture 68 Facade Service

Lecture 69 Property Injection Means Bastard Injection?

Lecture 70 Cyclic Dependencies

Lecture 71 Conclusion

Section 8: Clean Unit Tests

Lecture 72 Outline

Lecture 73 Singletons and Static Classes

Lecture 74 Too Many Interfaces

Lecture 75 Removing Interfaces

Lecture 76 Testing Trivial Code

Lecture 77 Test Single Concern

Lecture 78 More Unit Testing Best Practices

Lecture 79 Conclusion

Section 9: Clean Code and TDD

Lecture 80 Outline

Lecture 81 What is TDD?

Lecture 82 Red / Green / Refactor

Lecture 83 Three Laws of TDD

Lecture 84 Reading Roman Numerals

Lecture 85 Continuous Testing

Lecture 86 Tic-Tac-Toe (Crosses and Noughts)

Lecture 87 Conclusion

Lecture 88 BONUS Lecture

Beginner and intermediate level C# developers

Course Information:

Udemy | English | 7h 10m | 2.00 GB
Created by: Engineer Spock

You Can See More Courses in the Developer >> Greetings from CourseDown.com