תגובה אחת

בפוסט זה אדגים שני שימושים נפוצים בתבנית העיצוב Decorator.

Decorator היא תבנית עיצוב די נפוצה ושימושית ביותר. היא מאפשר הוספת פונקציונליות לאובייקט קיים בצורה דינאמית, מבלי לשנות את האובייקט המקורי.

אפשרות זו מונעת ירושה מיותרת או פותרת מקרים בהם אין אפשרות לירושה בכלל (Sealed).

עוד דבר שניתן לומר על תבנית זו הוא שהיא מתאימה ל Open Closed Principle– עיקרון זה של תכנות מונחה עצמים אומר שClass צריך להיות פתוח להרחבה, אבל סגור לשינויים. כלומר, סביר להניח שהושקעה מחשבה רבה על עיצוב הClass שלנו, ולכן לא נרצה לשנות אותו. אך מצד שני יתכן מצב שמישהו יצטרך באיזשהו שלב להוסיף פונקציונליות לקלאס.

מקרה נוסף שבו נרצה להשתמש ב Decorator הוא כאשר יש קוד ישן (הידוע בכינויו Legacy Code) שמסובך לשנות ובכלל לא מתחשק לגעת בו, אך לעיתים נצטרך להוסיף פונקציונליות.

ה Decorator מורכב מארבעה חלקים עיקריים (אפשר לצמצם את חלקם בהתאם למקרה הספציפי):

א. החלק הראשון הוא ה Component – זהו abstract class או Interface שאת אחד או כמה ממימושיו נרצה לשנות.

ב. החלק השני הוא ה Concrete Component – זהו Class (אחד או כמה) שיורשים או מממשים את ה Component.

ג. החלק השלישי הוא ה Decorator – זהו abstract class שגם הוא כמו ה Concrete Component יורש מה Component . המאפיין את ה Decorator הוא שיש לו Protected Member מהסוג של הComponent ושב Constructor שלו הוא מקבל מופע של Component כלשהו ומאתחל את ה Member (תיכף תבוא הדוגמא).

ד. החלק הרביעי הוא Concrete Decorator – Class (אחד או כמה) אשר יורשים מה Decorator, מוסיפים פונקציונליות משל עצמם וכמובן מממשים את הפונקציונליות הבסיסית, וזאת על ידי הפעלת הפונקציונליות של המופע שהתקבל בConstructor.

דוגמא א

נניח שהחומוסיה "מסבה-פול" (בן גוריון 18 ברמת גן, למי שמתעניין – תבקשו מנה משולשת) פנו אלי מכיוון שהתוכנה שבה הם משתמשים לא מתאימה לתפריטים המעודכנים שלהם והם רוצים להתאים אותה.

כרגע המצב הוא כזה – בתוכנה שלהם יש שלושה קלאסים: חומוס פרטי, חומוס זוגי, וחומוס משפחתי – שלושתם יורשים מקלאס "חומוס" כמובן ושלושתם ממשים GetDescription ו CalculateCost.

הקוד נראה כך:

   1: public abstract class Humus

   2:     {

   3:         public string Description { get; set; }

   4:         public abstract string GetDescriotion();

   5:         public abstract double CalculateCost();

   6:     }

   7:  

   8:     public class PrivateHumus : Humus

   9:     {

  10:         public PrivateHumus()

  11:         {

  12:             Description = "Private Humus";

  13:         }

  14:         public override string GetDescriotion()

  15:         {

  16:             return Description;

  17:         }

  18:  

  19:         public override double CalculateCost()

  20:         {

  21:             return 18.00;

  22:         }

  23:     }

  24:     public class DualHumus : Humus

  25:     {

  26:         public DualHumus()

  27:         {

  28:             Description = "Dual Humus";

  29:         }

  30:         public override string GetDescriotion()

  31:         {

  32:             return Description;

  33:         }

  34:  

  35:         public override double CalculateCost()

  36:         {

  37:             return 30.00;

  38:         }

  39:     }

  40:     public class FamilyHumus : Humus

  41:     {

  42:         public FamilyHumus()

  43:         {

  44:             Description = "Family Humus";

  45:         }

  46:         public override string GetDescriotion()

  47:         {

  48:             return Description;

  49:         }

  50:  

  51:         public override double CalculateCost()

  52:         {

  53:             return 45.00;

  54:         }

  55:     }

מה שקרה הוא שהם גילו שהלקוחות שלהם מעדיפים תוספות על החומוס שלהם, אז הם התחילו להגיש חומוס גרגירים, חומוס טחינה וחומוס מסבחה.

אם כך מה צריך לשנות בתוכנה?

אם נתחיל להוסיף קלאס לכל תוספת בנפרד וזה בהתאמה לגודל המנה, זה יראה כך FamilyHumusWithTehini, DualHumusWithTehini, PrivateHumusWithTehini וכו' וכו'… וכך הלאה לכל תוספת בנפרד.

ומה אם אני רוצה לשלב (מנה משולשת כזכור)?

ומה אם מחר הם ירצו להוסיף גם פול?

תהיה לנו התפוצצות קלאסים וקוד ספגטי.

אם כך נממש Decorator.

השלב הראשון הוא ליצור Abstract Class שיורש מ Humus

   1: public abstract class HumusDecorator : Humus

כעת ניצור שדה Protected של Humus

   1: protected  Humus Humus;

ניצור Constructor שמקבל Humus ונאתחל את השדה שלנו.

 

   1: protected HumusDecorator(Humus humus)

   2: {

   3:     Humus = humus;

   4: }

   5:  

כעת נממש את הפונקציות מהקלאס הראשי – Humus , אבל למעשה המימוש יהיה רק בהפעלת הפונקציות של המופע של Humus שקיבלנו.

ה Class בשלמותו נראה כך:

   1: public abstract class HumusDecorator : Humus

   2:     {

   3:         protected  Humus Humus;

   4:  

   5:         protected HumusDecorator(Humus humus)

   6:         {

   7:             Humus = humus;

   8:         }

   9:  

  10:         public override string GetDescriotion()

  11:         {

  12:             return Humus.GetDescriotion();

  13:         }

  14:  

  15:         public override double CalculateCost()

  16:         {

  17:             return Humus.CalculateCost();

  18:         }

  19:     }

כעת ניצור קלאסים לכל אחת מהתוספות והן כולן ירשו מהDecorator .

ההבדל ביניהם יהיה במימוש של הפונקציות.

הקוד יראה כך (אין לי אחריות על המחירים):

   1: public class Granules : HumusDecorator

   2:     {

   3:         public Granules(Humus humus) : base(humus)

   4:         {

   5:             Description = "Granules";

   6:         }

   7:  

   8:         public override string GetDescriotion()

   9:         {

  10:            return string.Format("{0}, {1}", Humus.GetDescriotion(), Description);

  11:  

  12:         }

  13:  

  14:         public override double CalculateCost()

  15:         {

  16:             return Humus.CalculateCost() + 3.00;

  17:         }

  18:     }

  19:  

  20:     public class Tehina : HumusDecorator

  21:     {

  22:         public Tehina(Humus humus)

  23:             : base(humus)

  24:         {

  25:             Description = "Tehina";

  26:         }

  27:  

  28:         public override string GetDescriotion()

  29:         {

  30:             return string.Format("{0}, {1}", Humus.GetDescriotion(), Description);

  31:  

  32:         }

  33:  

  34:         public override double CalculateCost()

  35:         {

  36:             return Humus.CalculateCost() + 2.00;

  37:         }

  38:     }

  39:     public class Msabbaha : HumusDecorator

  40:     {

  41:         public Msabbaha(Humus humus)

  42:             : base(humus)

  43:         {

  44:             Description = "Msabbaha";

  45:         }

  46:  

  47:         public override string GetDescriotion()

  48:         {

  49:             return string.Format("{0}, {1}", Humus.GetDescriotion(), Description);

  50:  

  51:         }

  52:  

  53:         public override double CalculateCost()

  54:         {

  55:             return Humus.CalculateCost() + 4.00;

  56:         }

  57:     }

תכלס זהו.

אז איך משתמשים בזה?

ניצור מופע של הHumus הרצוי לנו (נגיד PrivateHumes) אך הוא יהיה כללי (כלומר מ type Humus)

ולאחר מכן ניצור מופע חדש של התוספת הרצויה לנו המקבל ב Constructor את ה PrivateHumus שיצרנו והמופע יחליף את MyHumus.

כעת נוכל להדפיס מה שנרצה.

הקוד יראה כך:

   1: Humus myHumus = new PrivateHumus();

   2: myHumus = new Granules(myHumus);

   3: Console.WriteLine(myHumus.GetDescriotion());

   4: Console.WriteLine(myHumus.CalculateCost());

התוצאה כמובן תהיה כמצופה:

לכידה

 

 

דוגמא ב' – Sealed Class

נניח שיש לי תוכנה שיש לי Sealed Class שמממש איזשהו Interface.

הקוד נראה כך:

   1: public interface IDbHandler

   2:   {

   3:       void HandelDb(string sql);

   4:   }

   5:  

   6:   public sealed class SqlHandler : IDbHandler

   7:   {

   8:       public void HandelDb(string sql)

   9:       {

  10:           //Do Some Work

  11:       }

  12:   }

והשימוש בקוד נראה כך:

 

   1: public void Main()

   2: {

   3:     var db = new SqlHandler();

   4:     DoSomething(db);

   5: }

   6:  

   7: public void DoSomething(IDbHandler db)

   8: {

   9:     db.HandelDb("query");

  10: }

נשים לב שהמתודה DoSomthing לא מקבלת דווקא את הקלאס הספציפי שלנו אלא מימוש של הInterface.

ובכן, גילינו שיש לנו דליפת זיכרון בתוכנה.

השתמשנו באיזשהו Profiler וגילינו שהבעיה היא בקלאס שלנו – SqlHandler.

לשם הבדיקה נניח שאנחנו רוצים להדפיס כל sql שמגיע למתודה handelDb.

ניצור Decorator באופן הזה:

ניצור Class חדש אשר אף הוא מממש את IDbHandler ונדאג שיהיה לו שדה Protected מסוג IDbHandler וששדה זה מאותחל ב Constructor .

במתודה HandelDb נעשה שני דברים

א. התוספת שלנו – הדפסת ה sql.

ב. הפעלת המתודה המקורית מתוך הקלאס המקורי.

הקוד יראה כך:

   1: public class SqlDecorator : IDbHandler

   2: {

   3:     protected IDbHandler DbHandler { get; set; }

   4:     public SqlDecorator(IDbHandler db)

   5:     {

   6:         DbHandler = db;

   7:     }

   8:  

   9:     public void HandelDb(string sql)

  10:     {

  11:         Console.WriteLine(sql);

  12:         DbHandler.HandelDb(sql);

  13:     }

  14: }

כעת השימוש בקוד יהיה כמעט אותו דבר ויראה כך –

 

   1: public void Main()

   2: {

   3:     IDbHandler db = new SqlHandler();

   4:     var decorator = new SqlDecorator(db);

   5:  

   6:    

   7:     DoSomething(decorator);

   8: }

   9:  

  10: public void DoSomething(IDbHandler db)

  11: {

  12:     db.HandelDb("query");

  13: }

נרוויח הדפסה של כל sql שקיבלנו מבלי להפריע לעבודה הסדירה של התוכנה על פי המהלך המקורי.

· טיפ: במקרה כזה ובדומים לו ישנה דרך נוספת להוסיף פונקציונליות לקלאס קיים וזה על ידי Extension Methods. הדבר יוסבר כחלק מהפוסט הבא.

1

הוסף תגובה " class="ir icon-in">linkedin twitter email