Analysieren des Decorator-Musters in der C#-Entwurfsmusterprogrammierung

Decorator-Musterdefinition: Anstatt Klassenattributaktionen über abgeleitete Klassen hinzuzufügen oder zu ändern, wird dieser Effekt dynamisch durch Musterdesign erreicht. Dies ist bequemer und flexibler als die Vererbung und reduziert die Komplexität des Programms.

Beispiel

Wang Feng baut ein Meisterschaftsteam auf.

Zuallererst ist die Kategorie „Team“ leer. Durch die kontinuierlichen Bemühungen von Wang Feng konnte er Schüler für das Team gewinnen und eine geeignete Plattform für die Leistung der Teammitglieder schaffen.

Das Team wird immer stärker und vollständiger. Es sind die Dekorateure, die die Basisklasse entsprechend den unterschiedlichen Anforderungen hinzufügen und ändern und schließlich Ihre Zustimmung gewinnen und Ihre Anforderungen erfüllen.

Klassendiagramm, das das Assembler-Muster implementiert:

Teambildungscode

//汪峰战队
 abstract class WangFengTeam
 {
   //执行策划命令
   abstract public void Acrion();
 }
 
 //学员
 class Student : WangFengTeam
 {
   // Methods
   override public void Acrion()
   {
     Console.WriteLine("汪峰团队学员情况：");
   }
 }
 
 // 战队总策划
 abstract class Direct : WangFengTeam
 {
   //汪峰战队
   protected WangFengTeam team;
 
   // 策划活动
   public void SetComponent(WangFengTeam team)
   {
     this.team = team;
   }
   //执行策划
   override public void Acrion()
   {
     if (team != null)
     {
       team.Acrion();
     }
   }
 }
 
 //男孩唱狂放型的，构建一个组合。
 class BoyTeam : Direct
 {
   // 组合名称
   public string teamName= "锋利的Jquery";
 
   //具体策划
   override public void Acrion()
   {
     base.Acrion();
     Console.WriteLine("我是汪峰团队，狂放型的。");
   }
 }
 
 //女孩唱婉约型的，来个模特表演
 class GrilTeam : Direct
 {
   //具体策划
   override public void Acrion()
   {
     base.Acrion();      
 
     Console.WriteLine("我是汪峰团队，婉约型的。");
 
     //模特表演
     show();
   }
 
   public void show()
   {
     Console.WriteLine("婉约型，走秀");
   }
 }

Client-Code:

public static void Main()
   {
     Student team = new Student();
     BoyTeam boy = new BoyTeam();
     GrilTeam girl = new GrilTeam();
 
     //团队男孩装饰
     boy.SetComponent(team);
     //团队女孩装饰
     girl.SetComponent(boy);
     girl.Acrion();
     Console.Read();
   }

Vor- und Nachteile des Decorator-Musters
Nachdem wir die ausführliche Einführung des Decorator-Musters gelesen haben, wollen wir mit der Analyse seiner Vor- und Nachteile fortfahren.

Vorteile:

Der Zweck des Dekorationsmusters und der Vererbung besteht darin, die Funktionalität des Objekts zu erweitern, aber das Dekorationsmuster ist flexibler als die Vererbung

von Mithilfe verschiedener konkreter Dekorationsklassen und der Permutationen und Kombinationen dieser Klassen können Designer viele Kombinationen unterschiedlicher Verhaltensweisen erstellen.

Das Dekoratormuster weist eine gute Skalierbarkeit auf.

Nachteile:

Dekoration Ein Operatormuster führt zu vielen kleinen Objekten im Entwurf, und bei übermäßiger Verwendung wird das Programm komplexer. Und mehr Objekte machen es schwieriger, Fehler zu machen, insbesondere wenn sie alle gleich aussehen.

Verwendungsszenarien
Werfen wir einen Blick auf die spezifischen Situationen, in denen das Dekoratormuster verwendet wird:
Muss die Funktionalität einer Klasse erweitern oder Fügen Sie einer Klasse zusätzliche Verantwortlichkeiten hinzu.
Sie müssen einem Objekt dynamisch Funktionen hinzufügen, und diese Funktionen können dynamisch widerrufen werden.
Es müssen sehr viele Funktionen hinzugefügt werden, die durch Permutation und Kombination einiger Grundfunktionen generiert werden

Implementierung des Dekoratormusters in .NET
Es gibt auch ein Dekoratormuster in .NET-Klassenbibliothek Implementierung, diese Klasse ist System.IO.Stream. Werfen wir einen Blick auf die Stream-Klassenstruktur:

BufferedStream, CryptoStream und GZipStream sind eigentlich zwei spezifische Dekorationen Die Dekoratoren hier. Das Muster lässt die abstrakte Dekoratorrolle (Dekorator) weg. Im Folgenden wird gezeigt, wie der Client Funktionen dynamisch zu MemoryStream hinzufügen kann.

MemoryStream memoryStream = new MemoryStream(new byte[] {95,96,97,98,99});
      // 扩展缓冲的功能
      BufferedStream buffStream = new BufferedStream(memoryStream);
      // 添加加密的功能
      CryptoStream cryptoStream = new CryptoStream(memoryStream,new AesManaged().CreateEncryptor(),CryptoStreamMode.Write);
      // 添加压缩功能
      GZipStream gzipStream = new GZipStream(memoryStream, CompressionMode.Compress, true);

Zusammenfassung
Dies ist das Ende der Einführung in das Dekoratormuster. Das Dekoratormuster verwendet Objektzusammensetzung anstelle von Vererbung, um eine dynamische Erweiterung zur Laufzeit zu erreichen Objektfunktionen und die Möglichkeit, mehrere Funktionen nach Bedarf zu erweitern, wodurch die „schlechte Flexibilität“ und „Probleme bei der Ableitung mehrerer Unterklassen“ vermieden werden, die durch die alleinige Verwendung der Vererbung verursacht werden. Gleichzeitig steht es gut im Einklang mit den objektorientierten Designprinzipien „Objektkomposition gegenüber Vererbung bevorzugen“ und dem „Offen-Geschlossen“-Prinzip.

Weitere Artikel zur Analyse des Dekoratormusters in der C#-Designmusterprogrammierung finden Sie auf der chinesischen PHP-Website!