.NET Decoration Mode Explanation

Definition of decoration mode:

Decoration mode is the ability to dynamically extend the functionality of an object without changing the original class file and using inheritance. It wraps the real object by creating a wrapping object, that is, decoration.

Decorator pattern structure diagram:

Decorator pattern role:

(1) Abstract component (Component) role: Gives an abstract interface to standardize objects that are prepared to receive additional responsibilities.
(2) Concrete Component role: Define a class that will receive additional responsibilities.
(3) Decorator role: Holds an instance of a Component object and implements an interface consistent with the abstract component interface.
(4) Concrete Decorator role: Responsible for adding additional responsibilities to component objects.

Implementation:

Quoting examples from life, we bought a new mobile phone and slowly added new decorations to the phone, such as stickers and widgets...

1. First abstract Mobile phone class, as an abstract component in the decorator pattern:

/// <summary>
/// 手机抽象类,即抽象者模式中的抽象组件类
/// </summary>
public abstract class Phone
{
  /// <summary>
  /// 打印方法
  /// </summary>
  public abstract void Print();
}

2. Suppose we buy an Apple phone now and inherit from the abstract class to implement the specific component class:

/// <summary>
/// 苹果手机，即装饰着模式中的具体组件类
/// </summary>
public class ApplePhone:Phone
{
  /// <summary>
  /// 重写基类的方法
  /// </summary>
  public override void Print()
  {
    Console.WriteLine("我有一部苹果手机");
  }
}

3 .Now I want to add new decorations to this phone, let’s abstract the decoration class first:

/// <summary>
/// 装饰抽象类，让装饰完全取代抽象组件，所以必须继承Phone
/// </summary>
public abstract class Decorator:Phone
{
  private Phone p ;  //该装饰对象装饰到的Phone组件实体对象
   
  public Decorator(Phone p)
  {
    this.p = p;
  }
 
  public override void Print()
  {
    if (this.p != null)
    {
      p.Print();
    }
  }
}

4. Specific decoration objects, inherit the decoration abstract class: here are the specific film decoration, and pendant decoration:

/// <summary>
/// 贴膜，具体装饰者
/// </summary>
public class Sticker:Decorator
{
  public Sticker(Phone p) : base(p) { }
 
  public override void Print()
  {
    base.Print();
    //添加行为
    AddSticker();
  }
 
  /// <summary>
  /// 新的行为方法
  /// </summary>
  public void AddSticker()
  {
    Console.WriteLine("现在苹果手机有贴膜了");
  }
}

/// <summary>
/// 手机挂件，即具体装饰者
/// </summary>
public class Accessories:Decorator
{
  public Accessories(Phone p) : base(p) { }
 
  public override void Print()
  {
    base.Print();
 
    // 添加新的行为
    AddAccessories();
  }
 
  /// <summary>
  /// 新的行为方法
  /// </summary>
  public void AddAccessories()
  {
    Console.WriteLine("现在苹果手机有漂亮的挂件了");
  }
}

5. Call:

/// <summary>
/// 设计模式-装饰者模式
/// </summary>
class Program
{
  static void Main(string[] args)
  {
    Phone ap = new ApplePhone(); //新买了个苹果手机
    Decorator aps = new Sticker(ap); //准备贴膜组件
    aps.Print();
 
    Decorator apa = new Accessories(ap); //过了几天新增了挂件组件
    apa.Print();
 
    Sticker s = new Sticker(ap);    //准备贴膜组件
    Accessories a = new Accessories(s);//同时准备挂件
    a.Print();
  }
}

(1) Abstract component (Component) role: Give an abstract interface to standardize objects that are prepared to receive additional responsibilities.​​​​ >Here is the Phone interface
(2) Concrete Component role: Define a class that will receive additional responsibilities.                                                                                                                                                                                   ApplePhone
(3) Decorator role: Holds an instance of a component (Component) object and implements an interface consistent with the abstract component interface. > Refers to Decorator
(4) Concrete Decorator role: Responsible for adding additional responsibilities to component objects. & Gt; Refers to the purpose of Accessories and Sticker

:

1. Decorator mode and inheritance the purpose is to expand the function of the object, but Decorator can provide more flexibility than inheritance.
2. By using different specific decoration classes and the arrangement and combination of these decoration classes, designers can create many combinations of different behaviors.

Disadvantages:

1. This feature, which is more flexible than inheritance, also means more complexity.
2. Decoration mode will lead to many small classes in the design. If overused, the program will become very complicated.
3. Decoration mode is for abstract component (Component) type programming. However, if you are programming for specific components, you should rethink your application architecture and whether decorators are appropriate. Of course, you can also change the Component interface, add new public behaviors, and implement the "translucent" decorator mode. Make the best choice in actual projects.

The above is the entire content of this article. I hope it will be helpful to everyone’s learning. I also hope that everyone will support the PHP Chinese website.