— Decorator Pattern — Decorator Pattern

Decorator Pattern

The decorator pattern is a structural pattern that dynamically extends the functionality of an object without changing the original class file or using inheritance.

The decorator pattern creates a wrapper, that is, a wrapper around a real object.

role

The sample

The namespace DecoratorPattern contains the Car class, Maserati Class, Ferrari Fabbrica class, CoolCar class, Car sticker Paster class, and Car Visor class. This example gives a simple exterior decoration to the car using decorator mode.

public abstract class Car {

    public string Name { get; set; }

    public abstract void StartUp();

}
Copy the code

The Car base class, Car, acts as an abstraction.

public class Fabbrica : Car {
 
    public Fabbrica() {
        Name = "Fabbrica";
    }
 
    public override void StartUp() {
        Console.WriteLine($"{Name} is starting!"); }}Copy the code

The Ferrari Fabbrica class acts as a concrete artifact.

public class Maserati : Car {
 
    public Maserati() {
        Name = "Maserati";
    }
 
    public override void StartUp() {
        Console.WriteLine($"{Name} is starting!"); }}Copy the code

The Maserati class acts as a concrete building block.

public abstract class CoolCar : Car {
 
    protected Car _car = null;
 
    public CoolCar(Car car) {
        _car = car;
    }
 
    public override void StartUp() {
        Console.WriteLine($"{_car.Name} is starting!"); }}Copy the code

The CoolCar class acts as an abstract decoration.

public class Paster : CoolCar {
 
    public Paster(Car car) : base(car){}public override void StartUp() {
        SetPaster();
        base.StartUp();
    }
 
    private void SetPaster() {
        Console.WriteLine($"Set paster to {_car.Name}!"); }}Copy the code

The Paster class, which inherits the CoolCar class, makes it possible to decorate cars.

public class Visor : CoolCar {
 
    public Visor(Car car) : base(car){}public override void StartUp() {
        SetVisor();
        base.StartUp();
    }
 
    private void SetVisor() {
        Console.WriteLine($"Set visor to {_car.Name}!"); }}Copy the code

The car Visor class, by inheriting the CoolCar class, provides the possibility to decorate the car.

public class Program {

    private const string LINE_SPLIT = "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --";

    private static Car _car = null;

    private static CoolCar _coolCar = null;

    public static void Main(string[] args) {
        _car = new Maserati();

        _coolCar = new Visor(_car);
        _coolCar.StartUp();
        Console.WriteLine(LINE_SPLIT);

        _car = new Fabbrica();

        _coolCar = newPaster(_car); _coolCar.StartUp(); Console.WriteLine(LINE_SPLIT); Console.ReadKey(); }}Copy the code

This is the caller’s code, and here is the output of the case:

Set visor to Maserati!
Maserati is starting!
-------------------------
Set paster to Fabbrica!
Fabbrica is starting!
-------------------------
Copy the code

advantages

disadvantages

1. This more flexible nature than inheritance also means more complexity; 2. Decoration mode leads to many small classes in your design, which can complicate your application if overused. Decorator mode is designed for abstract Component types. However, if you are programming for specific components, you should rethink your application architecture and the appropriateness of decorators. You could also change the Component interface to add new exposed behaviors and implement a “translucent” decorator pattern. Make the best choice in the actual project.

Usage scenarios