Interested in a private company training? Request it here.
SOLID principles were introduced by Robert C. Martin (a.k.a Uncle Bob) in 2000. The intention of these principles is to make software designs more understandable, easier to maintain and extend. These principles are essential for every developer to know, because it will help them in writing better code an better understanding other code that was written with these principles in mind.
One might not believe it, but design patterns do not find their origin in software architecture. Patterns were first described in the 1970s by a real "Bricks and Stones" architect. A pattern is defined as a re-usable solution to a common type of problem, without ever repeating the actual way the solution is implemented. This means that patterns are an ideal learning tool and also ideal for communicating design ideas. Of course there are also anti-patterns, things often used, but actually better avoided.
When creating software, you feel yourself continuously creating new objects. Although the basic form of creating new objects is not bad, it can result in design problems or added complexity to the design. Creational patterns will help you deal with object creation that is suitable to the situation.
Once your objects are created, they start interacting. When you're not careful, these interactions can quickly start leading into code that is tightly coupled. Behavioral design patterns help with identifying common communication patterns between objects and realize these patterns. By correctly applying these patterns, you can increase flexibility in carrying out the interaction between objects.
Created objects do not tend to stand on their own. No, they start encapsulating other objects trying to create structure in, what otherwise would be a chaotic software environment. Structural patterns help at identifying and setting up relationships between objects.
Programming languages also use a bunch of patterns in their implementation. In this chapter you will build your own little programming language, which is extensible by the way. While doing so you will discover and apply some very important patterns which are perfectly useable outside of the scope of building programming languages!
Most developers make lousy graphic designers. That is why we see the emergence of patterns that allow developers to focus on writing code to implement the behavior of the application, while allowing graphics designers to build kick-ass user interfaces. The main pattern is called Model-View-*Whatever*, with *Whatever* replaced depending on the technology you are using. Understanding the MVW pattern is important as it is used to develop both windows and web applications.
Have you ever heard of Reactive Programming? This is an important new development where you learn to program using Observables. You will learn to apply this technique to solve some common, hard-to-solve problems with classic Object-Oriented Programming, and we will also explore the Fluxor/Redux pattern.
When do you need patterns the most?! When you are building a framework yourself. Building a framework means handling new features while keeping backward compatibility. This very hard task can be make easier with the proper use of patterns. So in this last part of the training we will build a reusable library, and while doing so encounter some problems and then solve these problems by applying the right pattern.
So how can you become a better developer? One of the best ways is by learning design patterns. Design Patterns provide reusable solutions to solve common software design problems. In this training we identify software design problems and see how to address these using the best suited Design Pattern. We will also look at modern C# language features, S.O.L.I.D. principles, and apply what we've learned. Modern day developers should also know about Reactive Programming which makes certain complex problems a breeze to implement. Finally we finish building a reusable library always keeping things like backward compatibility and developer ease-of-use in mind! We will also discuss some anti-patterns, such as 'string based programming'.
This course is intended for experienced programmers who are familiar with C# and have a working experience of .NET (Framework or Core). All examples and labs use the latest LTS version of .NET and Visual Studio. Labs also work with any recent .NET and VS version.