ממשקים מרובים

חלק מהיחידה תכנות מונחה עצמים במסלול ה-C# של Coddy. שיעור 27 מתוך 70.

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

כדי לממש כמה ממשקים, פשוט רשמו אותם אחרי הנקודתיים, מופרדים בפסיקים:

public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

public class Duck : IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("Flying through the air");
    }
    
    public void Swim()
    {
        Console.WriteLine("Swimming in the pond");
    }
}

המחלקה Duck חייבת לממש את כל האיברים של שני הממשקים. כך ממדלים באופן טבעי תרחישים מהעולם האמיתי — ברווז באמת יכול גם לעוף וגם לשחות, ולכן הגיוני שהוא יקיים את שני החוזים.

כשמשלבים ירושה עם כמה ממשקים, מחלקת הבסיס חייבת להופיע ראשונה:

public class Duck : Bird, IFlyable, ISwimmable
{
    // יורשת מ-Bird ומממשת את שני הממשקים
}

הגמישות הזו מאפשרת לך להרכיב התנהגויות ממקורות שונים. Robot עשוי לממש את IMovable, את IChargeable ואת ISpeakable. כל ממשק מייצג יכולת יחידה, והמחלקה שלך יכולה לשלב בדיוק את מה שהיא צריכה.

אתגר

קל

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

תחלקו את הקוד שלכם בין ארבעה קבצים:

IControllable.cs: הגדירו ממשק בשם IControllable במרחב השמות SmartHome. הממשק הזה מייצג מכשירים שאפשר להדליק ולכבות. עליו להצהיר על שתי מתודות: TurnOn() ו-TurnOff(), שכל אחת מהן מחזירה מחרוזת.
INetworkConnected.cs: הגדירו ממשק בשם INetworkConnected במרחב השמות SmartHome. הממשק הזה מייצג מכשירים שיכולים להתחבר לרשת. עליו להצהיר על מתודה בשם Connect(string network) שמחזירה מחרוזת.
SmartTV.cs: הגדירו מחלקה בשם SmartTV במרחב השמות SmartHome, שמממשת גם את IControllable וגם את INetworkConnected. לטלוויזיה צריכה להיות תכונה בשם Brand מסוג מחרוזת ותכונה בשם ScreenSize מסוג int, שמייצגת את הגודל באינצ'ים. צרו בנאי שמקבל את שני הערכים. ממשו את כל המתודות של הממשקים:
- TurnOn() מחזירה "{Brand} {ScreenSize}-inch TV is now ON"
- TurnOff() מחזירה "{Brand} {ScreenSize}-inch TV is now OFF"
- Connect(string network) מחזירה "{Brand} TV connected to {network}"
Program.cs: בקובץ הראשי, צרו SmartTV באמצעות ערכי הקלט. הדגימו את הגמישות של כמה ממשקים באמצעות אחסון אותו אובייקט טלוויזיה בשלושה סוגים שונים של משתנים: הסוג הקונקרטי SmartTV, משתנה מסוג IControllable ומשתנה מסוג INetworkConnected. קראו למתודות המתאימות דרך כל אחת מההפניות, כדי להראות כיצד אפשר להתייחס לאותו אובייקט בדרכים שונות, בהתאם לממשק שבו משתמשים.

תקבלו שלושה קלטים:

שם המותג של הטלוויזיה
גודל המסך באינצ'ים
שם הרשת שאליה יש להתחבר

הדפיסו את הפלט בפורמט הבא:

Via SmartTV:
{TurnOn() result}
{Connect(network) result}
Via IControllable:
{TurnOff() result}
Via INetworkConnected:
{Connect(network) result}

לדוגמה, אם הקלטים הם Samsung, 55 ו-HomeWiFi, הפלט צריך להיות:

Via SmartTV:
Samsung 55-inch TV is now ON
Samsung TV connected to HomeWiFi
Via IControllable:
Samsung 55-inch TV is now OFF
Via INetworkConnected:
Samsung TV connected to HomeWiFi

שימו לב שאפשר לגשת לאותו אובייקט SmartTV דרך הפניות שונות לממשקים. כששומרים אותו במשתנה מסוג IControllable, אפשר לקרוא רק למתודות שליטה. כששומרים אותו במשתנה מסוג INetworkConnected, אפשר לקרוא רק למתודות רשת. זה הכוח של מימוש כמה ממשקים — מחלקה אחת מקבלת כמה יכולות, ובו בזמן נשארת גמישה באופן השימוש בה!

נסו בעצמכם

using System;
using SmartHome;

class Program
{
    public static void Main(string[] args)
    {
        // קרא את הקלטים
        string brand = Console.ReadLine();
        int screenSize = Convert.ToInt32(Console.ReadLine());
        string network = Console.ReadLine();
        
        // TODO: צור אובייקט SmartTV עם ערכי הקלט
        
        // TODO: אחסן את אותו אובייקט טלוויזיה במשתנים משלושה טיפוסים שונים:
        // 1. הטיפוס SmartTV (מחלקה קונקרטית)
        // 2. הטיפוס IControllable (הפניה לממשק)
        // 3. הטיפוס INetworkConnected (הפניה לממשק)
        
        // TODO: הדפס את הפלט בפורמט הנדרש:
        // Via SmartTV:
        // - קרא ל־TurnOn() ול־Connect(network)
        // Via IControllable:
        // - קרא ל־TurnOff()
        // Via INetworkConnected:
        // - קרא ל־Connect(network)
        
    }
}