[23 Design Patterns] Prototype Pattern (5)

Preface

In a software system, when the process of creating an instance of a class is expensive or complicated, and we need to create multiple instances of such a class, if we use the new operator to create such a class instance, this will Increase the complexity of creating classes and the coupling between the creation process and client code complexity. If the factory model is used to create such instance objects, with the continuous increase of product classes, the number of subclasses will continue to increase, which will also lead to the increase of corresponding factory classes, and the maintenance code dimension will increase, because there are two types of products and factories. This dimension increases the complexity of the system, so it is not appropriate to use the factory pattern to encapsulate the class creation process here. Since each class instance is the same, the same refers to the same type, but the state parameters of each instance will be different, if the state value is also the same, it is meaningless, there is only one such object. When we need multiple instances of the same class, we can complete the creation by copying the original object. This idea is exactly how the prototype mode is implemented.

Definition of Prototype Pattern

In software systems, we are often faced with the creation of “some objects with complex structures”; due to changes in requirements, these objects often face drastic changes, but they are It has a relatively stable and consistent interface. How to deal with this change? How to isolate “these volatile objects” from the “client program”, so that “client programs that depend on these volatile objects” will not change as the requirements change? That is the Prototype pattern, use the prototype instance to specify the type of object to be created, and then create new objects by copying these prototypes.

The composition of the prototype pattern

• Prototype: prototype class, which declares an interface of Clone itself;

• ConcretePrototype: implement a Clone’s own operation.

In the prototype mode, Prototype usually provides an interface that contains the Clone method, and the specific prototype ConcretePrototype uses the Clone method to complete the object creation.

Implementation of Prototype Pattern

There are not many people who haven’t watched the movie “A Chinese Journey to the West: The Marriage of the Great Sage”. There is such a scene in it. The Bull Demon King used the Invincible Bull Lice to fight against the Supreme Treasure. The Supreme Treasure’s countermeasure was to take a pinch of monkey hair from the back of his head and blow his breath, and countless monkeys and grandchildren appeared to fight against the Bull Demon King’s Invincible Bull Lice. The monkey monkey grandson of Zhizunbao is the best embodiment of this prototype mode. Supreme Treasure creates a copy of itself, without having to re-incubate for five hundred years, then it is born, then learns art, and finally comes to fight the old cow. It is estimated that the day lily is cold. He has 3 life-saving monkey hairs, just blow them gently, and you can have as many as you want, which is convenient and fast.

Abstract Prototype

 /// 

     /// Abstract prototype, which defines the characteristics and actions of the prototype itself, this type is Supreme Treasure
     /// 
     public abstract class Prototype
     {
         /// 

         /// Combat - protect the master
         /// 
         public abstract void Fight();
         /// 

         /// Alms--don't starve master
         /// 
         public abstract void BegAlms();

         /// 

         /// Breathe fairy air--change yourself
         /// 
         /// 
         public abstract Prototype Clone();
     }
 

Concrete prototype

Create two concrete archetypes: Walker Sun and Sun Walker

Sun of the Walker:

 /// 

     /// Specific archetypes, for example: Pilgrim Sun, he is only responsible for fasting meals and fighting monsters in the lower realm of pets in the heavens
     /// 
     public sealed class XingZheSunPrototype : Prototype
     {
         /// 

         /// Fighting--protecting the master--fighting with nature to become a monster
         /// 
         public override void Fight()
         {
             Console.WriteLine("Walker Sun: Flying through the clouds and fog, fighting with monsters in the lower realm of pets in the heaven...");
         }
         /// 

         /// Alms--don't starve master--meals
         /// 
         public override void BegAlms()
         {
             Console.WriteLine("Walker Sun: Begging for chicken, fish, meat and eggs....");
         }

         /// 

         /// Breathe fairy air--change yourself
         /// 
         /// 
         public override Prototype Clone()
         {
             return (XingZheSunPrototype)this.MemberwiseClone();
         }
     }
 

Sun Walker:

 /// 

     /// Concrete prototype, for example: Sun Xing�, he is only responsible for the battle with the natural world and the transformation of fruit
     /// 
     public sealed class SunXingZhePrototype : Prototype
     {
         /// 

         /// Combat--Protect Master--Fight with Celestial Pets
         /// 
         public override void Fight()
         {
             Console.WriteLine("Sun Walker: Soaring through the clouds and driving the fog, fighting against the natural world to become a monster....");
         }
         /// 

         /// Alms--don't starve master---fruits
         /// 
         public override void BegAlms()
         {
             Console.WriteLine("Sun Walker: Begging for Fruits....");
         }

         /// 

         /// Breathe fairy air--change yourself
         /// 
         /// 
         public override Prototype Clone()
         {
             return (SunXingZhePrototype)this.MemberwiseClone();
         }
     }
 

Call

public void RunTest()
         {
             //prototype walker grandson
             Prototype xingZheSun = new XingZheSunPrototype();
             Prototype xingZheSun2 = xingZheSun. Clone();
             Prototype xingZheSun3 = xingZheSun. Clone();
             //No. 1 traveler Sun beats monsters
             xingZheSun. Fight();
             //No. 2 traveler Sun went to beg for alms
             xingZheSun3. BegAlms();
             Console.WriteLine("\r\n********************************\r\n");
             //Prototype Sunwalker
             Prototype sunXingZhe = new SunXingZhePrototype();
             Prototype sunXingZhe2 = sunXingZhe. Clone();
             Prototype sunXingZhe3 = sunXingZhe. Clone();
             Prototype sunXingZhe4 = sunXingZhe. Clone();
             Prototype sunXingZhe5 = sunXingZhe. Clone();

             //No. 1 Sunwalker fights monsters
             sunXingZhe. Fight();
             //No. 2 Sun Walker goes to beg for alms
             sunXingZhe2. BegAlms();

             //Battle and alms can also be classified. For example, alms can be divided into: fruit alms, food alms; battle can be divided into: the battle of heavenly pets becoming demons in the lower realm, and the battles of natural cultivation to become demons. You can think about it yourself.  Prototype mode is still useful

         }
 

Advantages and Disadvantages of the Prototype Pattern

Advantages

• The Prototype pattern hides the complexity of creating new instances from clients.

• The Prototype pattern allows dynamic addition or subtraction of product categories.

• The prototype pattern simplifies the creation structure of the instance. The factory method pattern needs to have the same hierarchical structure as the product class hierarchy, but the prototype pattern does not need this.

• The product class does not need to determine the hierarchical structure of the product in advance, because the prototype pattern is applicable to any hierarchical structure.

Disadvantages

• Each class must be equipped with a clone method.

• Equipping the clone method requires a comprehensive consideration of the functions of the class. This is not difficult for a new class, but it is not necessarily easy for an existing class, especially when a class references an indirect object that does not support serialization, or When the reference contains a circular structure.