The videos are not belong to me. I just wanted to create the example projects myself, to understand design patterns better.
Design pattern tutorial videos by Avish Links to the blog, are under the videos.
Design pattern tutorial videos by Michael
Design pattern tutorial videos by Scott Lilly
- 1. Creational patterns
- 2. Structural patterns
- 3. Behaviour patterns
- 4. Concurrency patterns
- 5. Architectural patterns
- A pattern is a way to describe a tested, proven solution or approach to a common design problem within a given context in software design.
- These patterns deal with object creation mechanisms, trying to create in a manner suitable to the situation.
- The basic form of object creation could result in design problems or added complexity to the design.
- Separate the construction of a complex object from its representation, allowing the same construction process to create various representations.
- Video: Scott Lilly - C# Design Patterns: The Builder Pattern
- Define an interface for creating a single object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses
- Video: Scott Lilly - C# Design Patterns: The Factory Pattern
- Specify the kinds of objects to create using a prototypical instance, and create new objects from the 'skeleton' of an existing object, thus boosting performance and keeping memory footprints to a minimum.
- Video: Michael - The Prototype Pattern
- Video: Scott Lilly - C# Design Patterns: The Prototype Pattern <- The best so far.
- Ensure a class has only one instance, and provide a global point of access to it.
- Video: kudvenkat - 02
- Video: kudvenkat - 03
- Video: Michael - The Singleton Pattern
- Video: Scott Lilly - C# Design Patterns: The Singleton Pattern <- The best so far.
- These patterns ease the design by identifying a simple way to realise relationships between entities.
- Convert the interface of a class into another interface clients expect. An adapter lets classes work together that could not otherwise because of incompatible interfaces. The enterprise integration pattern equivalent is the translator.
- Video: Michael - The Adapter Pattern
- Decouple an abstraction from its implementation allowing the two to vary independently.
- Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
- Video: Michael - The Composite Pattern
- classes should achieve polymorphic behavior and code reuse by their composition (by containing instances of other classes that implement the desired functionality) rather than inheritance from a base or parent class.
- Video: Scott Lilly - C# Design Patterns: Composition over Inheritance <- The best so far.
- Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternative to subclassing for extending functionality.
- Video: Michael - The Decorator Pattern - Warning Audio spikes! :(
- Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
- Video: Michael - The Facade Pattern
- Video: Scott Lilly - C# Design Patterns: The Wrapper/Facade Pattern
- Use sharing to support large numbers of similar objects efficiently.
- Provide a surrogate or placeholder for another object to control access to it.
- These patterns identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
- Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
- Encapsulate a request as an object, thereby allowing for the parameterization of clients with different requests, and the queuing or logging of requests. It also allows for the support of undoable operations.
- Video: Michael - The Command Pattern
- Video: Scott Lilly - C# Design Patterns: The Command Pattern
- Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
- Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
- Video: Michael - The Iterator Pattern
- Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it allows their interaction to vary independently.
- Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later.
- Video: Michael - The Memento Pattern
- Video: Scott Lilly - C# Design Patterns: The Memento Pattern
- Avoid null references by providing a default object.
- Video: Michael - The Null Object Pattern
- Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically.
- Video: Michael - The Observer Pattern
- Video: Scott Lilly - C# Design Patterns: Publish/Subscribe
- Allow an object to alter its behavior when its internal state changes. The object will appear to change its class
- Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
- Video: Michael - The Strategy Pattern
- Video: Scott Lilly - C# Design Patterns: The Strategy Pattern
- Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
- Video: Michael - The Template Method Pattern
- Represent an operation to be performed on the elements of an object structure. Visitor lets a new operation be defined without changing the classes of the elements on which it operates.
- These type of design patterns deal with the multi-threaded programming paradigm.
- An architectural pattern is a concept that solves and delineates some essential cohesive elements of a software architecture. Countless different architectures may implement the same pattern and share the related characteristics.
- The MVVM pattern makes easier to separate the development of the user interface from the business logic.
- Wiki
- Video: Scott Lilly - C# Design Patterns: MVVM (Model-View-ViewModel)
- The active record pattern is an approach to accessing data in a database. A database table or view is wrapped into a class. Thus, an object instance is tied to a single row in the table. After creation of an object, a new row is added to the table upon save. Any object loaded gets it's information from the database. When an object is updated, the corresponding row in the table is also updated. The wrapper class implements accessor methods or properties for each column in the table or view
- Wiki
- Video: Scott Lilly - C# Design Patterns: The Data Mapper pattern and the Active Record pattern
- A data mapper is a Data Access Layer that performs bidirectional transfer of data between a persistent data store (often a relational database) and an in-memory data representation (the domain layer). The goal of the pattern is to keep the in-memory representation and the persistent data store independent of each other, and the data mapper itself. The layer is composed of one or more mappers (or data access objects) performing the data transfer.
- Wiki
- Video: Scott Lilly - C# Design Patterns: The Data Mapper pattern and the Active Record pattern
- Dependency injection is a technique whereby one object supplies the dependencies of another object. A dependency is an object that can be used (a service). An injection is the passing of a dependency to a dependent object (a client) that would use it. The service is made part of the client's state. Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.
- The intent behind dependency injection is to decouple objects to the extent that no client code has to be changed simply because an object it depends on needs to be changed to a different one.
- Wiki
- Video: Scott Lilly - C# Design Patterns: The Dependency Injection Pattern