Master the Art of Writing Clean Code in C#

Master the Art of Writing Clean Code in C#, available at $79.99, has an average rating of 4.49, with 88 lectures, based on 1012 reviews, and has 6246 subscribers.

You will learn about 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 This course is ideal for individuals who are Beginner and intermediate level C# developers It is particularly useful for Beginner and intermediate level C# developers.

Enroll now: Master the Art of Writing Clean Code in C#

Summary

Title: Master the Art of Writing Clean Code in C#

Price: $79.99

Average Rating: 4.49

Number of Lectures: 88

Number of Published Lectures: 88

Number of Curriculum Items: 88

Number of Published Curriculum Objects: 88

Original Price: $59.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

Beginner and intermediate level C# developers

Target Audiences

Beginner and intermediate level C# developers

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 functions

Avoid common architectural smells.?Get rid of unpleasant smells

Apply principles of functional programming: achieve immutability, remove side effects, extend types

Avoid smells related to dependency injection

Write cleaner unit tests

Practice Test-Driven Development

Foundations 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, Encapsulation

How 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 errors

DI-related anti-patterns: control freak, hidden dependencies, temporal coupling, ambient context, facade service, bastard injection, cyclic dependencies

Clean Unit Tests: singletons and static classes, excessive number of interfaces, testing trivial code, testing of a single concern, different best practices

Practicing TDD: definition, 3 laws, parsing roman numerals, continuous testing, implementing Tic-Tac-Toe

The 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 Code

C# Best Practices

API?in?C#

Building API in C#

Clean Code in?C# tutorial

Refactoring

Course Curriculum

Chapter 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

Chapter 2: Programming Metaprinciples

Lecture 1: Outline

Lecture 2: DRY – Dont Repeat Yourself

Lecture 3: KISS – Keep it Simple, Stupid

Lecture 4: YAGNI – You Aint Gonna Need It

Lecture 5: Separation of Concerns (SoC)

Lecture 6: Command-Query Separation Principle (CQS)

Lecture 7: Principle of Least Astonishment

Lecture 8: Encapsulation and Information Hiding

Lecture 9: Conclusion

Chapter 3: Naming API Members

Lecture 1: Outline

Lecture 2: General Principles of Naming

Lecture 3: About Naming Once Again

Lecture 4: Naming Conventions in .NET

Lecture 5: Conclusion

Chapter 4: Writing Clean Functions

Lecture 1: Outline

Lecture 2: Variable Declaration on the Top

Lecture 3: Magic Numbers

Lecture 4: Stringly Typed Smell

Lecture 5: Property VS Method

Lecture 6: Implementing Parameters

Lecture 7: Too Many Parameters

Lecture 8: Too Long Methods

Lecture 9: Creational Patterns VS Constructors

Lecture 10: Extract Method Refactoring

Lecture 11: Simplifying Complex Logic

Lecture 12: Sequence of Arguments

Lecture 13: Guard Clauses and Early Returns

Lecture 14: Poor Conditional Clauses

Lecture 15: Output Parameters

Lecture 16: Comments

Lecture 17: Prefer Positive if-Statements

Lecture 18: Conclusion

Chapter 5: Common Architectural Design Smells

Lecture 1: Outline

Lecture 2: Primitives Obsession

Lecture 3: Violation of Law of Demeter

Lecture 4: Temporal Coupling

Lecture 5: Refactoring to Template Method Design Pattern

Lecture 6: Refactoring to Strategy Design Pattern

Lecture 7: Refactoring to State Design Pattern

Lecture 8: Conclusion

Chapter 6: Functional Programming: Extendibility and Immutability

Lecture 1: Outline

Lecture 2: Programming Paradigms

Lecture 3: Defining Functional Programming

Lecture 4: Functions, Functions, and Functions Again

Lecture 5: Why Functional Programming?

Lecture 6: Immutability. Intro

Lecture 7: Immutability of Structures

Lecture 8: Temporal Coupling and Immutability

Lecture 9: Pipelining

Lecture 10: Extending IDisposable

Lecture 11: General Extensions

Lecture 12: Extending StringBuilder

Lecture 13: Abusing Extension Methods

Lecture 14: Builder Design Pattern. Immutability and Testability

Lecture 15: Errors and Functional Programming

Lecture 16: Errors Handling: Pipelining by Method Chaining

Lecture 17: Conclusion

Chapter 7: DI-Related Anti-Patterns & Refactorings

Lecture 1: Outline

Lecture 2: Control Freak

Lecture 3: Hidden Dependencies and Service Locator

Lecture 4: Temporal Coupling and Constructor Injection

Lecture 5: Constructor Over-Injection

Lecture 6: Ambient Context

Lecture 7: Facade Service

Lecture 8: Property Injection Means Bastard Injection?

Lecture 9: Cyclic Dependencies

Lecture 10: Conclusion

Chapter 8: Clean Unit Tests

Lecture 1: Outline

Lecture 2: Singletons and Static Classes

Lecture 3: Too Many Interfaces

Lecture 4: Removing Interfaces

Lecture 5: Testing Trivial Code

Lecture 6: Test Single Concern

Lecture 7: More Unit Testing Best Practices

Lecture 8: Conclusion

Chapter 9: Clean Code and TDD

Lecture 1: Outline

Lecture 2: What is TDD?

Lecture 3: Red / Green / Refactor

Lecture 4: Three Laws of TDD

Lecture 5: Reading Roman Numerals

Lecture 6: Continuous Testing

Lecture 7: Tic-Tac-Toe (Crosses and Noughts)

Lecture 8: Conclusion

Lecture 9: BONUS Lecture

Instructors

Engineer Spock
Software Engineer – 1000+ Reviews, Average Score – 4.5

Rating Distribution

1 stars: 9 votes

2 stars: 24 votes

3 stars: 125 votes

4 stars: 390 votes

5 stars: 464 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!