SOLID is an acronym which stands for SRP, OCP, LSP, ISP and DIP. These five acronyms in their turn stand for:  

• Single Responsibility Principle  
• Open/Closed Principle  
• Liskov Substitution Principle  
• Interface Segregation Principle  
• Dependency Inversion Principle

In this course, you’ll learn how to apply meta and SOLID principles so that your application will live a long healthy life. 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  

• Understand the meta principles on which all the other development principles are based  
• Understand the symptoms of code defects  
• Learn the foundations of SOLID principles
• Learn how to detect the violations of SOLID principles and how to fix the problems
• Learn how meta principles and SOLID principles are related to each other and how to find the balance between them  

Foundations of writing object-oriented code

Despite the fact that C# is a very rich on features language, it's very common to see poorly designed and implemented applications in a real world. Language by itself does not guarantee that the architecture of an application will be great. In order to design and build maintainable software, we need to understand the principles of software development. This video course is exactly about how to achieve clean and maintainable software.  

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 decent professional.  

Content and Overview  

This course is aimed at middle and senior developers. Solid experience in C# is required.  

There are plenty of code examples throughout this course so that you will learn both theoretical and practical material.  

Starting with SOLID principles we will go further to the meta-principles. Going through the SOLID principles, you’ll also learn about the related patterns. Then we will get to the problem of contradictions between different principles. You’ll learn about the relationships between SOLID principles and meta principles.  

In general, you’ll learn in this course:  

• SRP  
• OCP  
• LSP  
• ISP  
• DIP  

These are the SOLID principles. You’ll learn the background problems that can be solved by particular principle, you’ll see the demonstrations in code, you’ll learn the related patterns to every principle.  

Learning DIP you’ll in addition learn what is Dependency Injection, Inversion of Control, IoC-Containers and what are the architectural implications of DI.  

Here are other topics you’ll learn in the course:  

• DRY – don’t repeat yourself  
• KISS – keep it simple stupid  
• YAGNI – You Ain’t Gonna Need It  
• SoC – separation of concerns  
• CQS – command query separation  
• Law of Demeter  
• Principle of Least Astonishment  
• Information Hiding and Encapsulation  
• API Development Principles  
• Contradiction between SOLID and YAGNI  
• Contradiction between OCP and YAGNI  
• What is Architecture and Design

Teaching Approach

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth.

Take this course, and you will be satisfied!

------------------------------------------------------------

Keywords related to the course:

• Software Architecture
• SOLID Principles Tutorial C#
• SOLID Tutorial C#
• Software Design
• SOLID Principles
• SRP, OCP, LSP, ISP, DIP

Teaching Approach

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All the important concepts are covered. Particularly important topics are covered in-depth. For absolute beginners, I offer my help on Skype absolutely free, if requested. 

Take this course, and you will be satisfied. 

Build a solid foundation in software architecture applying Dependency Injection with IoC-Containers

In many of my courses I use techniques of Dependency Injection and each time students write me private messages saying that they don't what it is and thus they don't understand what's going on in the course I teach. This is very unfortunate from the learning perspectives.

Dependency Injection is the set of techniques that allow to supply dependencies to objects. Actually, if you have ever passed dependencies via constructors, then you applied the so-called constructor injection. Dependency Injection (DI) is simple and difficult at the same time. On one hand, DI is comprised of simple techniques and on the other hand, when we need to bring DI to the next level, we need to make things more complicated using the so-called DI or IoC (Inversion of Control) Containers. These are the frameworks which perform dependency injection automatically. You just need to set one up in the application root (an extremely important notion which you'll learn about in the course) and after that, it will resolve all the dependencies it knows about in the runtime.

If you still don't understand what am I talking about, just believe me, you absolutely need to know about Dependency Injection. This course will tremendously improve your understanding of how software architectures emerge. So, this course is "must watch" for anyone who still doesn't understand what is DI and IoC-Containers.

Content and Overview 

This course is aimed at all kind of developers. It provides solid theoretical base reinforced by practical material. 

The course covers:

• Introduction to Inversion of Control:
• Dependency Inversion Principle (DIP), Inversion of Control (IoC), Dependency Injection (DI),
• Dependencies and their types, Pure DI and IoC-Containers, Service Locator
• The Architectural Implications of Dependency Injection
• DI-related Anti-Patterns & Refactorings: 
• Control Freak, Hidden Dependencies, Temporal Coupling,
• Constructor Over-Injection and how to avoid it,
• Ambient Context, Facade Service, Property Injection vs Bastard Injection, Cyclic Dependencies
• Refactoring Example of an existing code base applying Dependency Injection
• How to reap the fruits of DI
• DI-Containers (IoC-Containers):
• Overview, Unity, Late Binding with Unity, Aspect-Oriented Programming (AOP), Interception vs Pure DI vs AOP Tools,
• Setting up a bootstrapper with Unity, Autofac and Castle.Windsor

Learn how to write C# code in a functional style. The “Functional Programming in C#” is for you if you want to improve your code, design and architecture. It means you are going to learn how to write code of the high quality: readable, understandable and reliable.

Learn Functional Programming in the context of clean coding and building types of high quality 

• Get Deep Understanding of what is Functional Programming 
• Learn how to design Immutable types in C# 
• Apply new C# 6 and C# 7 features to write better code in a functional style 
• Learn how to Extend and Compose any Types 
• Handle Errors and Exceptions in a functional programming style 
• Tackle the Problem of Null-Values by the means of functional programming 

Foundations of Functional Programming

Despite the fact that C# is primarily an object-oriented language, it is very powerful on features which enable functional programming style. 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 well-designed and well-implemented types with regards to functional programming principles. 

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 types. 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. 

• We’re going to start with the theoretical foundations of the functional programming paradigm. You’ll learn what is Functional Programming and what are the benefits of applying that paradigm.
• In the second section, we’re going to elaborate the core concepts of the functional programming. You’ll learn more about immutability, purity, side effects and expressions.
• To write modern code in a functional style, you need to learn modern C# features appeared in C# 6 and C# 7.
• We’re going to learn more about immutability in a separate section. This is a very important topic.
• We’re going to learn how to extend types. You’ll see practical cases, you’ll learn about general extensions needed for functional programming.
• After mastering the topic of types extending you will face the great problem of exceptions handling. Yep, it's a hard nut to crack. We will start from discussing a question of why we use exceptions as a mechanism of errors handling. And why C# team didn't invent any other mechanisms?
• In the end, we will look at how to fight with null values. As you may know, Tony Hoar said that the invention of a null value was his billion-dollar mistake.

To sum up, the course covers the following topics: 

• Theoretical Foundations of Functional Programming 
• Core Concepts of Functional Programming 
• Functional Features in C# 
• Immutability in C# 
• Extendibility in C# 
• Dealing with Errors 
• Dealing with Nulls 

------------------------------------------------------------ 

Keywords related to the course: 

• C# Clean Code 
• C# Best Practices 
• Functional Programming in C# 
• C# Functional Programming 
• Clean Code in C# tutorial

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#!