Hey, it's me, Yannick, the co-instructor of this course.
Welcome to this section of the course.
We are talking about C sharp clean code.
So how you can build clean and solid code.
Clean code is code that is easy to read, understand, maintain and following consistent standards and
best practices.
So let's take a look at the benefits of clean code.
So when you follow along with all of the things that you will learn during this section, you will come
up with these benefits.
Here you will have a better code quality.
You will have improved maintainability.
So you or other developers will be able to maintain and extend your code right.
You will be able to reuse your code more often whenever you need it.
You will be able to reduce the complexity whenever needed.
And finally you will see less bugs, that's for sure.
So in this Clean Code section, we will cover naming conventions.
I know we have already talked about that, but again, we will just skim through all the naming cases.
So pascalcase all caps case, camel case and so on and when to use them.
Then we move on to structuring interfaces, classes and methods.
That one is really interesting and it prepares us for the solid principles.
Then we will discover refactoring.
So how to professionally refactor your code so that you improve its quality.
And then we will get to one of the main parts of clean code which are the solid principles.
So those are five principles, right?
One for each letter S, o, L, I and D just one sentence for each of them.
Single responsibility pattern means that every class should have one functionality, basically one responsibility.
The open closed principle says that you should be able to extend your code, but you should not change
your existing code, right?
So you open for extension but closed for modification.
Then we have the Liskov Substitution principle, which says that whenever you derive a class, you should
be able to use the base class without causing any problems.
We will get through all of that.
When we reach the section on solid principles, we will go into that in depth.
No worries.
We have the interface segregation, which basically means if we have one bloated interface with lots
of functionality, and we have classes that implement that interface but do not use the methods, then
we should split up that interface, cut it down into smaller interfaces so that every class only implements
what it really needs.
And then finally we have the dependency inversion principle that one says that you should not couple
high level functionality with low level functionality.
Again, we'll get to that when we reach the solid principles section.
So by the end of this section you will be able to create extendable, maintainable and highly professional
code that is full of the C sharp best practices.
So let's get started with the first lesson on C sharp clean code.