constants (קבועים) הם תאים בזיכרון אשר מכילים ערך קבוע שאינו ניתן לשינוי (בניגוד למשתנים שמטבעם כן יכולים להשתנות). קבועים ב – NET. למעשה מוגדרים אוטומטית כ- static (אין צורך לציין זאת במפורש), הדבר אומר שהגישה אליהם היא דרך שם המחלקה ולא דרך אובייקט.

הגדרת const:

  class MyConst
  {
    public const double PI = 3.14159;
  }

גישה ל - const:

   Console.WriteLine(MyConst.PI);

Readonly

readonly (קריאה-בלבד) הינו משתנה קבוע, אשר בניגוד ל- const אינו מוגדר כ- static אלא מוגדר עבור כל אובייקט. זאת אומרת שהערך שלו יכול להיות שונה בכל מופע של האובייקט, אך מרגע שנוצר האובייקט לא ניתן לשנות אותו. ניתן להכניס לתוכו ערך בשורת ההצהרה עליו (כלומר אתחול כמו const) ו / או בבנאי (c'tor) בלבד. לאחר האתחול ובניית המופע של המחלקה לא ניתן עוד לשנות את ערכו של משתנה זה.

להלן דוגמא להגדרת readonly והשמת ערך בבנאי.

  שימו לב שהפונקציה ()ChangeValue תגרור שגיאת קומפילציה כי ניתן לבצע השמה רק באתחול או בבנאי:

class TestReadonly
  {
    //read-only data-member:
    private readonly int val;
 
    //read-only Property:
    public int Val
    {
      get { return val; }
    } 
 
    //Ctor:
    public TestReadonly(int v)
    {
      val = v;
    }
 
    //Method:
    public void ChangeValue()
    {
      val = 10;  // !שגיאת קומפילציה
    }
  } 

 שימו לב שבד"כ למשתנה read-only יהיה property שהוא read-only (כלומר, ללא חלק של set), מיכוון שלא ניתן לשנות את ערך המשתנה לאחר שהוא כבר נוצר ואותחל.

      TestReadonly t1 = new TestReadonly(10);
      TestReadonly t2 = new TestReadonly(12);
 
      Console.WriteLine(t1.Val);
      Console.WriteLine(t2.Val);

הורשה הינה אחד מהעקרונות החשובים ביותר בתכנות מונחה עצמים (OOP). הורשה מאפשרת לממש את עקרון ה- reuse – שימוש חוזר בקוד ללא צורך לכתוב אותו מספר פעמים.

מימוש הורשה

בכדי לממש הורשה ב C# יש לכתוב במחלקה היורשת את מחלקת הבסיס שלה בצורה הבאה:

  class Base
  {
 
  }
 
  class Derived : Base
  {
 
  }

דגשים חשובים לגבי הורשה:

• כל מה שיש במחלקה עובר בהורשה כולל: משתנים, properties, פונקציות וכו'. למעט בנאים (c'tors).
• אלמנטים שמוגדרים כ- private עוברים בהורשה אך לא ניתן לגשת אליהם מהמחלקה היורשת.
• השימוש במחלקה היורשת הוא כשימוש במחלקה רגילה.
• במחלקה היורשת חובה להפעיל בנאי כלשהו ממחלקת הבסיס.
• הבנאי של מחלקת הבסיס יופעל קודם לבנאי של המחלקה היורשת.
• אם לא נציין במפורש איזה בנאי נרצה להפעיל יופעל אוטומטית הבנאי שאינו מקבל פרמטרים.

הפעלת בנאי ממחלקת הבסיס מתבצעת באמצעות המילה השמורה base ובאותה שיטה בה השתמשנו להפעלת בנאי אחר מאותה מחלקה (באמצעות this):

  class Base
  {
    public Base(int x)
    {
      //...
    }
  }
 
  class Derived : Base
  {
    public Derived(int x, int y)
      : base(x)
    {
      //...
    }
  }

דריסת פונקציות

לעיתים קיימת פונקציה במחלקת הבסיס אך היא אינה מתאימה בדיוק במימוש שלה למחלקה היורשת. לדוגמא: פונקציה שמדפיסה את כל המאפיינים של המחלקה. לעיתים היא לא מתאימה כלל ולעיתים היא מתאימה חלקית. ב- C# ניתן לדרוס פונקציה שקיבלנו ממחלקת הבסיס ואם נרצה (לא חובה) נוכל להשתמש בתוך המחלקה היורשת גם בפונקציה שקיבלנו ממחלקת הבסיס. השימוש יתבצע באמצעות המילה השמורה base ולאחריה נקודה וקריאה לפונקציה.

לדוגמא:

  class Base
  {
    public void Print()
    {
      //...
    }
  }
 
  class Derived : Base
  {
 
    public new void Print()
    {
      //...
      base.Print();
      //...
    }
  }

דוגמא מלאה להורשה:

להלן דוגמא מלאה להורשה הכוללת מחלקת בסיס בשם Person ושתי מחלקות יורשות בשם Employee,Student.

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

תרשים המחלקות:

  class Person
  {
    //Fields:
    string firstName;
    string lastName;
 
    //Properties:
 
    public string FirstName
    {
      get { return firstName; }
      set { firstName = value; }
    }
 
    public string LastName
    {
      get { return lastName; }
      set { lastName = value; }
    }
 
    //C'tors:
 
    public Person()
      : this("", "")
    {
    }
 
    public Person(string firstName, string lastName)
    {
      FirstName = firstName;
      LastName = lastName;
    }
 
    //Methods:
    public string Print()
    {
      return string.Format("\nName: {0} {1}",
                           FirstName, LastName);
    }
  }

  class Employee : Person
  {
    //Fields:
    private double salary;
 
    //Properties:
    public double Salary
    {
      get { return salary; }
      set
      {
        if (value < 0)
          throw new Exception("Illegal salary");
 
        salary = value;
      }
    }
 
    //C'tors:
    public Employee()
    {
      Salary = 0;
    }
 
    public Employee(string fName, string lName, double salary)
      : base(fName, lName)
    {
      Salary = salary;
    }
 
    //Methods:
    public new string Print()
    {
      return base.Print() 
             + string.Format("\nSalary: {0}", Salary);
    }
  }

  class Student : Person
  {
    //Fields:
    private int[] grades;
 
    //Properties:
    public int[] Grades
    {
      get { return grades; }
      set { grades = value; }
    }
 
    //C'tors:
    public Student()
    {
      Grades = new int[5];
    }
 
    public Student(string fName, string lName, int[] grades)
      : base(fName, lName)
    {
      Grades = grades;
    }
 
    //Methods:
    public new string Print()
    {
      string str = base.Print() + "\nGrades:\t";
 
      foreach (int g in Grades)
        str += g + "\t";
 
      return str;
    }
  } 

  class Program
  {
    static void Main(string[] args)
    {
      Employee e1 = new Employee();
      Employee e2 = new Employee("Lior", "Zamir", 25000);
 
      Console.WriteLine("Employees:");
      Console.WriteLine(e1.Print());
      Console.WriteLine(e2.Print());
 
      int[] grades = new int[] { 90, 100, 85 };
 
      Student s1 = new Student();
      Student s2 = new Student("Avi", "Levi", grades);
 
      Console.WriteLine("\n--------------\n\nStudents:");
      Console.WriteLine(s1.Print());
      Console.WriteLine(s2.Print());
 
    }
  }

פלט התוכנית:

פולימורפיזם (רב-צורתיות) הינה היכולת לתת מימוש שונה לאותה הפונקציה במחלקה היורשת כך שבזמן ריצה תופעל הפונקציה שמתאימה לטיפוס האובייקט. גם בנושא זה דנו במאמר המבוא ל- OOP ובמאמר זה נלמד איך לממש זאת. פולימורפיזם מתבסס על הורשה ואין פולימורפיזם ללא הורשה.

מימוש Polymorphism

בכדי לממש פולימורפיזם יש תחילה להגדיר את הפונקציה במחלקת הבסיס כוירטואלית (virtual) ובמחלקה היורשת להגדיר לדרוס אותה באמצעות override. לאחר מכן יש ליצור ייחוס ממחלקת הבסיס שיצביע על אובייקט מסוג המחלקה היורשת ולהפעיל את הפונקציה.

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

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

בדוגמא הבאה תופעל הפונקציה Print השייכת למחלקה היורשת:

  class Program
  {
    static void Main(string[] args)
    {
      Base b = new Derived();
      Console.WriteLine(b.Print());
    }
  }
 
  class Base
  {
    public int X { get; set; }
 
    public virtual string Print()
    {
      return "Base print";
    }
  }
 
  class Derived : Base
  {
    public int Y { get; set; }
 
    public override string Print()
    {
      return "Derived print";
    }
  }

גישה לאובייקט

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

לדוגמא אם ננסה לבצע זאת נקבל שגיאת קומפילציה:

      b.Y = 10;

נצטרך לבצע זאת כך:

      Derived d = (Derived)b;
      d.Y = 10;

או בקיצור:

      ((Derived)b).Y = 10;

שימושים של Polymorphism:

• יצירת מערך הטרוגני – ניתן ליצור מערך מסוג הבסיס כך שכל איבר במערך יהיה אובייקט מסוג יורש וכאשר נרוץ על המערך ונפעיל את הפונקציה, תופעל הפונקציה המתאימה לאובייקט. היתרון הוא שלא נצטרך לבדוק עבור כל איבר מה הטיפוס שלו.
• קבלה לפונקציה – ניתן לבנות פונקציה המקבלת משתנה מסוג בסיס ולשלוח אליה בכל פעם אובייקט מסוג אחר היורש את הבסיס.

דוגמא מלאה ל- Polymorphism:

להלן דוגמא מלאה הכוללת מימוש של פולימורפיזם בהורשה עם מספר דורות ושימושים של פולימורפיזם.

תרשים המחלקות:

  class Person
  {
    //Fields:
    string firstName;
    string lastName;
 
    //Properties:
 
    public string FirstName
    {
      get { return firstName; }
      set { firstName = value; }
    }
 
    public string LastName
    {
      get { return lastName; }
      set { lastName = value; }
    }
 
    //C'tors:
 
    public Person()
      : this("", "")
    {
    }
 
    public Person(string firstName, string lastName)
    {
      FirstName = firstName;
      LastName = lastName;
    }
 
    //Methods:
    public virtual string Print()
    {
      return string.Format("Name: {0} {1}",
                           FirstName, LastName);
    }
  }

 class Student : Person
  {
    //Fields:
    private int[] grades;
 
    //Properties:
    public int[] Grades
    {
      get { return grades; }
      set { grades = value; }
    }
 
    //C'tors:
    public Student()
    {
      Grades = new int[5];
    }
 
    public Student(string fName, string lName, int[] grades)
      : base(fName, lName)
    {
      Grades = grades;
    }
 
    //Methods:
    public override string Print()
    {
      string str = base.Print() + "\nGrades:\t";
 
      foreach (int g in Grades)
        str += g + ";";
 
      return str;
    }
  }

class Employee : Person
  {
    //Fields:
    private double salary;
 
    //Properties:
    public double Salary
    {
      get { return salary; }
      set
      {
        if (value < 0)
          throw new Exception("Illegal salary");
 
        salary = value;
      }
    }
 
    //C'tors:
    public Employee()
    {
      Salary = 0;
    }
 
    public Employee(string fName, string lName, double salary)
      : base(fName, lName)
    {
      Salary = salary;
    }
 
    //Methods:
    public override string Print()
    {
      return base.Print() +
             string.Format("\nSalary: {0}", Salary);
    }
  }

 class Manager : Employee
  {
    //Fields:
    private double bonus;
 
    //Properties:
    public double Bonus
    {
      get { return bonus; }
      set
      {
        if (value < 0)
          throw new Exception("Illegal bonus");
 
        bonus = value;
      }
    }
 
    //C'tors:
    public Manager()
    {
      Bonus = 0;
    }
    public Manager(string fName, string lName,
                   double salary, double bonus)
      : base(fName, lName, salary)
    {
      Bonus = bonus;
    }
 
    //Methods:
    public override string Print()
    {
      return base.Print() +
             string.Format("\tBonus: {0}", Bonus);
    }
  }

 class Program
  {
    static void Main(string[] args)
    {
      Person[] pArr = new Person[5];
      pArr[0] = new Person("A","AA");
      pArr[1] = new Employee("B", "BB",10000);
      pArr[2] = new Student("C", "CC",new int[]{80,100,90});
      pArr[3] = new Person("D", "DD");
      pArr[4] = new Manager("E", "EE",20000,5000);
 
      foreach (Person p in pArr)
      {
        Console.WriteLine("\n"+p.GetType().Name);
        Console.WriteLine(p.Print());
      }
 
      Person p1 = new Person("Avi", "Levi");
      Manager m1 = new Manager("Lior", "Zamir", 20000,5000);
 
      Console.WriteLine("\n---------\nPrinting Person:");
      PrintPerson(p1);
 
      Console.WriteLine("\nPrinting Manager:");
      PrintPerson(m1);
    }
 
    static void PrintPerson(Person p)
    {
      Console.WriteLine(p.Print());
    }
  }

פלט התוכנית:

לעיתים נרצה לבנות Collection (אוסף) משלנו אשר יכיל בתוכו אובייקטים מסוג שאנו נבנה ויספק לנו את הפונקציונאליות הקשורה לאובייקטים שלנו. ישנם הרבה דרכים ליצור Custom collection, החלק מלבנות מאפס ועד לרשת מ- Collection קיים, לכל שיטה היתרונות והחסרונות שלה. לצורך ההבנה של הדברים בצורה מיטבית נתמקד בשיטה של לעטוף Collection קיים.

הרעיון הוא לבנות מחלקה אשר תחזיק בתוכה משתנה מסוג ArrayList ותחשוף החוצה את הפונקציונאליות הנדרשת.

מכיוון שאנו בונים מחלקה ישנה בעיה בגישה אליה באמצעות סוגריים מרובעים [ ] מכיוון שניתן לגשת רק למערכים באמצעות סוגריים מרובעים. לכן במחלקת ה- collection שלנו נבנה property מיוחד שנקרא indexer (סדרן) המאפשר גישה באמצעות [ ].

להלן דוגמא מלאה ל- Custom Collection עבור המחלקות שבנינו בפרק הפולימורפיזם, כולל מימוש indexer ושימוש ב- Collection:

using System.Collections;
 
namespace CustomCollections
{
  class PersonCollection : IEnumerable
  {
    //Fields:
    private ArrayList pArr;
 
    //C'tors:
    public PersonCollection()
    {
      pArr = new ArrayList();
    }
 
    //Properties:
    public int Count
    {
      get
      {
        return pArr.Count;
      }
    }
 
    //Indexers:
 
    public Person this[int idx]
    {
      get
      {
        return (Person)pArr[idx];
      }
      set
      {
        pArr[idx] = value;
      }
    }
 
    public Person this[string fName]
    {
      get
      {
        for (int i = 0; i < Count; i++)
          if (this[i].FirstName == fName)
            return this[i]; //return the Person
 
        return null;  //Person not Found!
      }
    }
 
    //Methods:
 
    public void Add(Person newPerson)
    {
      pArr.Add(newPerson);
    }
 
    public void Remove(Person p)
    {
      pArr.Remove(p);
    }
 
    public void RemoveAt(int idx)
    {
      pArr.RemoveAt(idx);
    }
 
    public string PrintAll()
    {
      string str = "";
 
      for (int i = 0; i < Count; i++)
      {
        //str+=((Person)pArr[i]).Print();
        //Same as:
        str += this[i].Print() + "\n";
      }
 
      return str;
    }
 
    public double GetSumSalary()
    {
      double sum = 0;
 
      for (int i = 0; i < Count; i++)
      {
        if (this[i] is Employee)
          sum += ((Employee)this[i]).Salary;
      }
 
      return sum;
    }
 
 
    #region IEnumerable Members
 
    public IEnumerator GetEnumerator()
    {
      return pArr.GetEnumerator();
    }
 
    #endregion
  }
}

using System;
 
namespace CustomCollections
{
  class Program
  {
    static void Main(string[] args)
    {
      PersonCollection pcol = new PersonCollection()
      {
        new Person("A","AA"),
        new Employee("B", "BB",10000),
        new Student("C", "CC",new int[]{80,100,90}),
        new Person("D", "DD"),
        new Manager("E", "EE",20000,5000)
      };
 
      //using indexer (set):
      pcol[3] = new Person("Lior", "Zamir");
 
      //using indexer (get):
      Console.WriteLine("** The fourth person:"
                        + pcol["Lior"].Print());
 
      Console.WriteLine("\n** Printing all persons:\n"
                        + pcol.PrintAll());
 
      Console.WriteLine("\n** Sum Salary (Employees only):\n"
                        + pcol.GetSumSalary());
    }
  }
}

פלט התוכנית:

אחד מתפקידי ה- interface העיקריים הוא ליצור ממשק זהה לאובייקטים שונים (אפילו בהיררכיות שונות) ובכך הוא אחד היישומים של עיקרון הפולימורפיזם בתכנות מונחה העצמים (OOP).

דוגמא ל- interface:

  interface IPrint
  {
    string Print();
  }

דגשים חשובים לגבי interface

• אינו יכול להכיל משתנים או מימושים (פונקציות עם תוכן) אלא רק הצהרות. המחלקות/מבנים שירשו את ה- interface הם אלה שיממשו את ההצהרות.
• כאשר נממש (נירש) interface חובה לממש את כל ההצהרות שבו
• ניתן לרשת רק מחלקה אחת ובנוסף ניתן לרשת ולממש מספר בלתי מוגבל של interfaces
• לא ניתן ליצור אובייקט מ- interface אלא רק ייחוס (reference)
• גם struct יכול לרשת מ- interface
• נהוג ששם של interface יתחיל באות I

דוגמא למימוש interface:

  class Person : IPrint
  {
    public string Print()
    {
      return "Hello";
    }
  }

דוגמא לשימוש ב- interface:

   IPrint p = new Person();
   Console.WriteLine(p.Print());

Interface הינו למעשה חוזה בין מחלקות המאפשר למתכנת לבנות תבנית ולבנות שירות המבוסס על תבנית זו וכל אחד שיממש את התבנית יוכל להשתמש בשירות זה.

בסביבת ה- NET. יש מספר רב של interface המאפשרים להשתמש בשירותים שונים הקיימים בסביבה. להלן דוגמא לכמה מהם:

• IComparable
• IComparer
• IEnumerable
• IEnumerator

ניקח כדוגמא את הממשק IComparable המספק פונקציה אחת להשוואה בין אובייקטים:

  public interface IComparable
  {
    int CompareTo(object obj);
  }

להלן התיעוד של הפונקציה CompareTo המסביר מה צריך להיות הערך החוזר:

//The return value has these meanings:
//Value Meaning Less than zero This instance is less than obj. 
//Zero This instance is equal to obj.
//Greater than zero This instance is greater than obj.

השימוש ב- interface מאפשר להשתמש בשירותים ב- .NET הדורשים השוואה כגון מיון. אם נרצה לאפשר יכולת כזו למחלקה שלנו נצטרך לממש את ה- interface לפי הקווים המנחים המופיעים בתיעוד.

לדוגמא נבנה מחלקה Person ונבצע את ההשוואה לפי הגיל:

  public class Person : IComparable
  {
    public int Age { get; set; }
 
    public string Print()
    {
      return string.Format("Age: {0}", Age);
    }
 
    public int CompareTo(object obj)
    {
      Person p = (Person)obj;
 
      if (Age < p.Age)
        return -1;
 
      if (Age > p.Age)
        return 1;
 
      return 0;
    }
  }

עכשיו ניתן להשתמש בשירות Sort הקיים במחלקה Array אשר משתמש ב- interface כדי לבצע את ההשוואה:

 class Program
  {
    static void Main(string[] args)
    {
      Person[] persons = new Person[]
      {
        new Person() { Age = 25 },
        new Person() { Age = 17 },
        new Person() { Age = 30 }
      };
 
      Console.WriteLine("Before Sorting:");
      foreach (Person p in persons)
        Console.WriteLine(p.Print());
 
      Array.Sort(persons);
 
      Console.WriteLine("\nAfter Sorting:");
      foreach (Person p in persons)
        Console.WriteLine(p.Print());
    }
  }

בפלט ניתן לראות את מצב המערך לפני ואחרי המיון:

להלן טבלה המסכמת את הרשאות הגישה ב- #C:

מחלקה אבסטרקטית הינה מחלקה אשר מהווה בסיס למחלקות אחרות, אך אין לנו באמת צורך באובייקטים ממנה בתוכנית.

• בכדי ליצור מחלקה אבסטרקטית יש לכתוב abstract לפני שם ה- class
• לא ניתן ליצור אובייקטים ממחלקה אבסטרקטית
• ניתן ליצור ייחוס ממחלקה אבסטרקטית (בד"כ לצורכי פולימורפיזם)
• מחלקה אבסטרקטית יכולה להכיל כל דבר שמחלקה רגילה יכולה להכיל
• מחלקה אבסטרקטית יכולה (אבל לא חייבת) להכיל פונקציות אבסטרקטיות
• לא ניתן לכתוב פונקציה אבסטרקטית במחלקה שהיא לא אבסטרקטית
• פונקציה אבסטרקטית היא פונקציה שאין לה מימוש. היא נכתבת כהצהרה ללא גוף (כלומר ללא בלוק של פקודות)
• כאשר יורשים מחלקה אבסטרקטית חובה לממש את כל הפונקציות האבסטרקטית שבה (אם יש)
• המימוש של פונקציה אבסטרקטית הוא באמצעות מילת המפתח override

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

  abstract class Shape
  {
    public abstract double GetArea();
  }

  class Circle : Shape
  {
    public double Radius { get; set; }
 
    public override double GetArea()
    {
      return Math.PI * Radius * Radius;
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      Shape b = new Circle() { Radius = 5 };
      Console.WriteLine(b.GetArea());
    }
  }

השוואה בין virtual ל- abstract