![Structural Design Patterns In C#]()
If you are new, I highly recommend you to read my first article which is about Creational Design Patterns In C#. As we explained in an earlier post, we have three main categories in Design Patterns,
- Creational
- Structural
- Behavioral
Structural Design Patterns help you to put types and objects and other stuff together to create a bigger struct but at the same time, it keeps high flexibility and optimum performance for you. There are seven patterns that exists in this family,
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
Adapter Design Pattern
As its name implies, the adapter pattern adjusts communication between two alien types and make them understand each other.
public class AlienType {
public string SayJupiterianHi() {
return "Hello Man from Earth, I am from JUPITER";
}
}
public interface IAdapter {
string SayHi();
}
public class Adapter: IAdapter {
private readonly AlienType _alienType;
public Adapter(AlienType alienType) {
_alienType = alienType;
}
public string SayHi() {
return _alienType.SayJupiterianHi();
}
}
public static class AdapterExample {
public static void Test() {
var adapter = new Adapter(new AlienType());
Console.WriteLine(adapter.SayHi());
}
//result:
//Hello Man from Earth, I am from JUPITER
}
Bridge Design Pattern
This pattern separates interface or abstraction from its implementation, so for example you may be using two different technologies in two implementations.
public interface IBridge {
void PrintDetails();
}
public class BridgeA: IBridge {
public void PrintDetails() {
Console.WriteLine("data across Bridge A");
}
}
public class BridgeB: IBridge {
public void PrintDetails() {
Console.WriteLine("data across Bridge B");
}
}
public interface IBridgeUser {
public IBridge Bridge {
get;
set;
}
void PrintDetails();
}
public class BridgeUser: IBridgeUser {
public IBridge Bridge {
get;
set;
}
public void PrintDetails() {
Bridge.PrintDetails();
}
}
public static class BridgeExample {
public static void Test() {
var bridgeUser = new BridgeUser();
bridgeUser.Bridge = new BridgeA();
bridgeUser.PrintDetails();
bridgeUser.Bridge = new BridgeB();
bridgeUser.PrintDetails();
}
//result:
//data across Bridge A
//data across Bridge B
}
Composite Design Pattern
In simple words, we put objects in one bigger object with a tree structure so we can present hierarchies, and also this pattern let you treat uniformly with a single object or composite object.
public abstract class Animal {
protected string Name;
protected Animal(string name) {
Name = name;
}
public virtual void Add(Animal animal) {
throw new NotImplementedException();
}
public virtual void PrintTree(int indent) {
throw new NotImplementedException();
}
}
public class Species: Animal {
public Species(string name): base(name) {}
public override void PrintTree(int indent) {
Console.WriteLine(new String('-', indent) + " " + Name);
}
}
public class SpeciesComposite: Animal {
private readonly List < Animal > _animals = new List < Animal > ();
public SpeciesComposite(string name): base(name) {}
public override void Add(Animal animal) {
_animals.Add(animal);
}
public override void PrintTree(int indent) {
Console.WriteLine(new String('-', indent) + "+ " + Name);
// Display each child element on this node
foreach(var animal in _animals) {
animal.PrintTree(indent + 2);
}
}
}
public static class CompositeExample {
public static void Test() {
var mammal = new SpeciesComposite("Mammal");
var carnivore = new SpeciesComposite("Carnivore");
var nonCarnivore = new SpeciesComposite("Non-Carnivore");
var tiger = new Species("Tiger");
var leopard = new Species("Leopard");
var sheep = new Species("Sheep");
var cow = new Species("Cow");
carnivore.Add(tiger);
carnivore.Add(leopard);
nonCarnivore.Add(sheep);
nonCarnivore.Add(cow);
mammal.Add(carnivore);
mammal.Add(nonCarnivore);
mammal.PrintTree(1);
}
//result:
//-+ Mammal
//---+ Carnivore
//----- Tiger
//----- Leopard
//---+ Non-Carnivore
//----- Sheep
//----- Cow
}
Decorator Design Pattern
This pattern helps you to extend your object responsibilities dynamically with less subclassing.
public interface ICar {
public string Tire {
get;
}
public string Engine {
get;
}
public abstract void ShowParts();
}
public class NormalCar: ICar {
public string Tire => "Pirelli";
public string Engine => "v4";
public void ShowParts() {
Console.WriteLine(this.ToJson());
}
}
public class SportCarDecorator: ICar {
private readonly ICar _car;
public SportCarDecorator(ICar car) {
_car = car;
}
public string Tire => _car.Tire;
public string Engine => _car.Engine;
public string Nitro => "NOS";
public void ShowParts() {
Console.WriteLine(this.ToJson());
}
}
public static class DecoratorExample {
public static void Test() {
var normalCar = new NormalCar();
normalCar.ShowParts();
var decoratedCar = new SportCarDecorator(normalCar);
decoratedCar.ShowParts();
}
//result:
//{"Tire":"Pirelli","Engine":"v4"}
//{"Tire":"Pirelli","Engine":"v4","Nitro":"NOS"}
}
Facade Design Pattern
This pattern gathers all interfaces or complex systems of classes or frameworks or etc, and makes using them simple for you.
public class Facade {
private readonly SubSys1 _subSys1;
private readonly SubSys2 _subSys2;
public Facade(SubSys1 subSys1, SubSys2 subSys2) {
_subSys1 = subSys1;
_subSys2 = subSys2;
}
public void Action() {
_subSys1.Action();
_subSys2.Action();
}
}
public class SubSys1 {
public void Action() {
Console.WriteLine("i am action by subsys1");
}
}
public class SubSys2 {
public void Action() {
Console.WriteLine("i am action by subsys2");
}
}
public static class FacadeExample {
public static void Test() {
var subsys1 = new SubSys1();
var subsys2 = new SubSys2();
var facade = new Facade(subsys1, subsys2);
facade.Action();
}
//result:
//i am action by subsys1
//i am action by subsys2
}
Flyweight Design Pattern
Mainly target of using this pattern is to save your memory by using shared objects.
public class Flyweight {
private readonly List < KeyValuePair < string, Heavy >> _sharedObjects = new();
public Flyweight() {
_sharedObjects.Add(new KeyValuePair < string, Heavy > ("A", new Heavy()));
_sharedObjects.Add(new KeyValuePair < string, Heavy > ("B", new Heavy()));
_sharedObjects.Add(new KeyValuePair < string, Heavy > ("C", new Heavy()));
}
public Heavy GetObject(string key) {
return _sharedObjects.SingleOrDefault(c => c.Key == key).Value;
}
}
public interface IHeavy {
public void Operation(string name);
}
public class Heavy: IHeavy {
public void Operation(string name) {
Console.WriteLine(name);
}
}
public static class FlyweightExample {
public static void Test() {
var flyweight = new Flyweight();
flyweight.GetObject("A").Operation("Hey");
flyweight.GetObject("B").Operation("We Are Using");
flyweight.GetObject("C").Operation("Shared Memory");
var heavy = new Heavy();
heavy.Operation("But I am bad and use my own memory");
}
//result:
//Hey
//We Are Using
//Shared Memory
//But I am bad and use my own memory
}
Proxy Design Pattern
This pattern uses a middle type to control access to main type.
public abstract class MainAbstraction {
public abstract void Call();
}
public class Main: MainAbstraction {
public override void Call() {
Console.WriteLine("calling by Main class");
}
}
public class Proxy: MainAbstraction {
private Main _main;
public Proxy(Main main) {
_main = main;
}
public override void Call() {
_main ?? = new Main();
Console.WriteLine("proxy do some work before calling");
_main.Call();
}
}
public static class ProxyExample {
public static void Test() {
var proxy = new Proxy(new Main());
proxy.Call();
}
//result:
//proxy do some work before calling
//calling by Main class
}
That's it. Congratulation! now you have been familiar with the basic patterns of Structural Design. I will explain the last main category in two different articles because Behavioral Design includes many patterns and it is better to split it into two articles.