Bridge is a structural design pattern that lets you split a large class into two separate hierarchies - abstraction and implementation, which can be developed independently of each other.
Brief introduction + demo code ↓
#designpatterns #dotnet #csharp #coding #programming
- Bridge is a structural design pattern that lets you split a large class into two separate hierarchies - abstraction and implementation, which can be developed independently of each other. Brief introduction + demo code ↓ #designpatterns #dotnet #csharp #coding #programming
In this example, we will work with various kinds of documents with the support to format and represent each document independently. First, we will define IFormatter interface as well as a few options for document formatting.Formatters represent the implementation dimension of Bridge pattern. Next, we need to tackle the abstraction part, which will be a document in this case.The "abstraction" defines the contract for the control part of the two-class hierarchies. It maintains a reference to an object of the "implementation" hierarchy and usually delegates all of the real work to this object.The "implementation" interface provides only primitive operations, while the abstraction defines higher-level operations based on those primitives.Consider a TV device that acts as the implementation, whereas the remote acts as the abstraction. The device defines a primitive operation to set volume, whereas remotes can make users life easier and offer the possibility to mute the device (mute will internally call set volume)Full implementation of a device/remote example, as well as an example that shows how to use enums to achieve bridge design pattern, can be found onUse the Bridge pattern when you want to divide and organize a monolithic class that has several variants of some functionality. Use this pattern when you need to extend a class in several orthogonal (independent) dimensions or if you need to switch implementations at runtime..+ The client code works with high-level abstractions. It isn’t exposed to the platform details. Abstraction and the implementation are developed independently and the client code can access only the abstraction part without being concerned about the Implementation part.+ You can introduce new abstractions and implementations independently from each other (Open/Closed Principle) + It increases the loose coupling between abstraction and its implementation+ You can focus on high-level logic in the abstraction and on platform details in the implementation (Single Responsibility Principle) - You might make the code more complicated by applying the pattern to a highly cohesive class.
