תבנית Factory Method
כדי ליצור אובייקט בשפת #C משתמשים ב־new. זה פשוט, ברור, ובדרך כלל גם מספיק.
אבל כשאנחנו כותבים:
var sender = new EmailSender();
אנחנו מקבלים גם החלטה: הקוד הזה יעבוד עם EmailSender. אם נרצה להשתמש במימוש אחר, נצטרך לשנות את הקוד או לתת לו דרך אחרת לקבל את האובייקט.
תבנית Factory Method עוסקת בהחלטה הזו. היא שייכת למשפחת תבניות היצירה של כנופיית הארבעה, ומאפשרת למחלקה להשתמש באובייקט שאת הסוג המדויק שלו קובעות המחלקות שיורשות ממנה.
לפני שנגיע אליה, כדאי לעבור דרך פתרון פשוט יותר. המילה Factory משמשת לתיאור כמה דברים שונים, ולא כל מתודה שיוצרת אובייקט היא מימוש של התבנית.
מערכת לשליחת הודעות
נניח שאנחנו מפתחים מערכת ששולחת הודעות למשתמשים. בגרסה הראשונה כל ההודעות נשלחות במייל.
נגדיר אינטרפייס לשליחה:
public interface IMessageSender
{
void Send(string destination, string message);
}
ומחלקה שמממשת אותו:
public class EmailSender : IMessageSender
{
public void Send(string destination, string message)
{
Console.WriteLine(
$"Email to {destination}: {message}");
}
}
בדוגמאות נסתפק בהדפסה למסך. במערכת אמיתית המתודה תפנה לספק שליחת הודעות, ובדרך כלל תהיה אסינכרונית. כרגע מה שמעניין אותנו הוא המבנה של הקוד.
המחלקה שאחראית על תהליך השליחה תיראה כך:
public class NotificationService
{
public void Notify(string destination, string message)
{
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentException(
"Destination is required.",
nameof(destination));
}
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentException(
"Message is required.",
nameof(message));
}
IMessageSender sender = new EmailSender();
sender.Send(destination, message.Trim());
}
}
יש לנו בדיקות בסיסיות, הכנה של ההודעה ושליחה. הכול עובד.
שימו לב שלמרות שהמשתנה sender מוגדר באמצעות אינטרפייס, המחלקה עדיין מכירה את EmailSender, מפני שהיא יוצרת אותה בעצמה. השימוש באינטרפייס לא מעלים את התלות שנוצרת בשורת ה־new.
מוסיפים SMS
כעת אנחנו רוצים לשלוח גם הודעות SMS. נוסיף מימוש:
public class SmsSender : IMessageSender
{
public void Send(string destination, string message)
{
Console.WriteLine(
$"SMS to {destination}: {message}");
}
}
אפשר להוסיף תנאי בתוך Notify שיבחר איזו מחלקה ליצור. אבל אם יש כמה מקומות במערכת שצריכים לבצע את הבחירה הזו, נעדיף לרכז אותה.
ניצור מחלקה ייעודית:
public enum NotificationChannel
{
Email,
Sms
}
public static class MessageSenderFactory
{
public static IMessageSender Create(
NotificationChannel channel)
{
return channel switch
{
NotificationChannel.Email => new EmailSender(),
NotificationChannel.Sms => new SmsSender(),
_ => throw new ArgumentOutOfRangeException(
nameof(channel))
};
}
}
ובתוך תהליך השליחה נשתמש בה כך:
IMessageSender sender =
MessageSenderFactory.Create(channel);
sender.Send(destination, message.Trim());
כעת הקוד ששולח הודעות אינו צריך להכיר את הבנאים של מחלקות השליחה. אם מחר EmailSender תדרוש פרמטר נוסף בבנאי, יש מקום מרכזי שבו נוכל לטפל בכך.
לפתרון הזה מקובל לקרוא Simple Factory.
זה פתרון שימושי בפני עצמו. אין צורך למהר להחליף אותו. אבל זו עדיין אינה תבנית Factory Method של כנופיית הארבעה.
ההבדל הוא שבפתרון הנוכחי מחלקה אחת מקבלת פרמטר ומחליטה מה ליצור. בתבנית שאליה אנחנו מתקדמים, ההחלטה תתבצע באמצעות ירושה: כל מחלקה יורשת תספק את המימוש המתאים לה.
נקודת הרחבה בתוך תהליך קיים
נשנה מעט את הדרישה.
אנחנו רוצים לספק תהליך שליחת הודעות שאפשר להרחיב. התהליך הבסיסי נשאר באחריותנו, אבל מי שיוסיף ערוץ שליחה יוכל לקבוע איזה אובייקט יבצע את השליחה בפועל.
במקום ליצור את האובייקט ישירות, נקרא למתודה בשם CreateSender:
public abstract class NotificationService
{
public void Notify(string destination, string message)
{
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentException(
"Destination is required.",
nameof(destination));
}
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentException(
"Message is required.",
nameof(message));
}
IMessageSender sender = CreateSender();
sender.Send(destination, message.Trim());
}
protected abstract IMessageSender CreateSender();
}
המתודה Notify יודעת מה לעשות עם האובייקט שתקבל. היא רק לא יודעת מאיזו מחלקה הוא יהיה.
המתודה CreateSender מוגדרת כ־abstract, ולכן המחלקות היורשות חייבות לממש אותה:
public class EmailNotificationService : NotificationService
{
protected override IMessageSender CreateSender()
{
return new EmailSender();
}
}
public class SmsNotificationService : NotificationService
{
protected override IMessageSender CreateSender()
{
return new SmsSender();
}
}
זו ה־Factory Method שלנו: המתודה CreateSender, שהמימוש שלה נקבע במחלקה היורשת.
אפשר להשתמש בקוד כך:
NotificationService notifications =
new EmailNotificationService();
notifications.Notify(
"reader@example.com",
"Your account is ready.");
ולשליחת SMS:
NotificationService notifications =
new SmsNotificationService();
notifications.Notify(
"+972501234567",
"Your account is ready.");
בשתי הדוגמאות אנחנו מפעילים את אותה מתודת Notify. היא לא נכתבה מחדש במחלקות היורשות. כאשר היא מגיעה לקריאה ל־CreateSender, מופעל המימוש המתאים לסוג האובייקט שיצרנו.
כלומר, המחלקה היורשת משפיעה על התהליך באמצעות האובייקט שהיא מספקת לו.
מי עושה מה
בספרות של התבנית מופיעים ארבעה שמות. עכשיו אפשר לחבר אותם לקוד שלנו:
| התפקיד בתבנית | בדוגמה |
|---|---|
| Product | האינטרפייס IMessageSender |
| Concrete Product | המחלקות EmailSender ו־SmsSender |
| Creator | המחלקה NotificationService, שמגדירה את מתודת היצירה ומשתמשת בתוצאה |
| Concrete Creator | המחלקות היורשות, שמממשות את CreateSender |
המילה Creator עלולה ליצור רושם שמדובר במחלקה שכל תפקידה הוא ליצור אובייקטים. בדוגמה שלנו אפשר לראות שזה לא המצב. האחריות שלה היא ניהול תהליך ההודעה, ויצירת אובייקט השליחה היא שלב בתוך התהליך.
גם השימוש ב־abstract אינו חובה בכל מימוש של התבנית. אפשר להגדיר מתודה virtual שמחזירה מימוש ברירת מחדל, ולאפשר למחלקה יורשת להחליף אותו לפי הצורך.
מוסיפים ערוץ נוסף
אם נרצה להוסיף שליחת Push, נוסיף מימוש של האינטרפייס:
public class PushSender : IMessageSender
{
public void Send(string destination, string message)
{
Console.WriteLine(
$"Push to {destination}: {message}");
}
}
ומחלקה יורשת:
public class PushNotificationService : NotificationService
{
protected override IMessageSender CreateSender()
{
return new PushSender();
}
}
לא שינינו את Notify, וגם לא את המחלקות ששולחות מייל או SMS.
עם זאת, מישהו עדיין צריך לבחור להשתמש ב־PushNotificationService. התבנית לא מנחשת מה המשתמש רוצה. הבחירה עשויה להימצא בקוד האתחול, בהגדרות האפליקציה או במקום שמתרגם בחירה של משתמש לשירות המתאים.
זה הבדל שכדאי לשים אליו לב כשמדברים על עקרון Open/Closed: הצלחנו להרחיב את תהליך השליחה בלי לערוך את המימוש המשותף שלו. לא הבטחנו שאפשר להוסיף יכולת שלמה בלי לגעת בשום מקום אחר במערכת.
ואפשר גם בלי הירושה הזו
אם כל מה שמשתנה הוא אובייקט השליחה, יש פתרון נוסף שכדאי לשקול: לקבל אותו בבנאי.
public class NotificationService
{
private readonly IMessageSender _sender;
public NotificationService(IMessageSender sender)
{
_sender = sender;
}
public void Notify(string destination, string message)
{
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentException(
"Destination is required.",
nameof(destination));
}
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentException(
"Message is required.",
nameof(message));
}
_sender.Send(destination, message.Trim());
}
}
והשימוש:
var notifications =
new NotificationService(new EmailSender());
notifications.Notify(
"reader@example.com",
"Your account is ready.");
בדוגמה הקטנה שלנו זו בהחלט אפשרות פשוטה יותר. אין צורך במחלקת שירות נפרדת לכל ערוץ.
זהו שימוש ב־Dependency Injection. הוא פותר כאן את הצורך לבחור מבחוץ את מימוש השליחה, בלי להשתמש ב־Factory Method המבוססת על ירושה. אם נצטרך ליצור אובייקט חדש בכל הפעלה, אפשר להזריק גם רכיב יצירה מתאים במקום מופע קבוע.
אז למה ללמוד את התבנית?
מפני שיש מערכות שבהן ירושה היא כבר הדרך שבה מרחיבים את ההתנהגות. למשל, ספרייה שמספקת מחלקת בסיס עם תהליך משותף, ומאפשרת למפתחים ליצור מחלקות יורשות שמותאמות לצרכים שלהם. במבנה כזה, מתודה שאפשר לדרוס כדי לספק אובייקט לתהליך היא נקודת הרחבה טבעית.
לעומת זאת, אם אנחנו בונים היררכיה שלמה רק כדי להחליף שורת new, כדאי לבדוק אם באמת הרווחנו משהו.
הבחירה במימוש
בדוגמה התחלנו ביצירה ישירה, עברנו ל־Simple Factory והגענו ל־Factory Method. זה סדר ההסבר, לא מסלול שכל מערכת אמורה לעבור ככל שהיא גדלה.
במערכת שבה יש מימוש אחד ואין צורך בהרחבה, יצירה ישירה יכולה להספיק. כשיש בחירה משותפת בין כמה מימושים, Simple Factory יכולה לרכז אותה. וכאשר מחלקות יורשות צריכות לקבוע איזה אובייקט ישתלב בתהליך שמחלקת הבסיס מנהלת, Factory Method מתאימה למבנה הזה.
במקרה של מערכת ההודעות המצומצמת שהצגנו, הייתי מתחיל דווקא מהזרקת IMessageSender. אם הייתי מתכנן ספרייה שהמשתמשים שלה מרחיבים באמצעות ירושה, הייתי שוקל את מתודת היצירה. ההיכרות עם התבנית עוזרת לבחור בין האפשרויות, גם כשהבחירה בסוף היא לא להשתמש בה.