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
