לעיתים נרצה לבנות 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());
    }
  }
}

פלט התוכנית:

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

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

הפונקציה בדוגמא הבאה, מקבלת 2 פרמטרים גנריים. הראשון חייב להיות struct היורש משני הממשקים IComparable, IFormattable. הפרמטר השני חייב להיות class היורש מהממשק ICloneable:

    public void MethodWithConstrain<T, K>(T a, K b)
      where T : struct, IComparable, IFormattable
      where K : class, ICloneable
    {
      Console.WriteLine(a);
      Console.WriteLine(b);
    }

דוגמא נוספת – שימו לב ל- 11 ההעמסות של פונקצית Max של מחלקת Math: 

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

    public static T Max<T>(T a, T b)
        where T : IComparable
    {
      if (a.CompareTo(b) > 0)
        return a;
 
      return b;
    }

פונקציה זו יכולה להשוות בין שני פריטים כלשהם, מכל class/struct קיים/עתידי כל עוד הוא עונה לקריטריון הבא: יורש מהממשק IComparable.

Console.WriteLine(Max<int>(3, 5));
Console.WriteLine(Max<double>(9.5, 3.6));
Console.WriteLine(Max<string>("Hi", "Bye"));
Console.WriteLine(Max<DateTime>(DateTime.Now,
                                new DateTime(2011, 2, 1)));
Console.WriteLine(Max<Person>(p1, p2));

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

הפלט:

באופן זה ניתן להגביל גם את הטיפוסים במחלקות (נחייב את הטיפוס לממש את IComparable):

  class Point <T>
    where T : IComparable
  {
    …
  }

ב- Net. קיימים מספר אוספים הנמצאים ב- namespace הנקרא System.Collections. להלן דוגמא למספר אוספים נפוצים:

• ArrayList – מייצג אוסף דינמי של פריטים.
• Hashtable – מייצג אוסף של זוגות ערכים (key/value) הממויין לפי ה- hash code של ה- key.
• SortedList – מייצג אוסף של זוגות ערכים (key/value) הממויין לפי הערך של ה- key.
• Queue – מייצג אוסף של פריטים בתור (הראשון שנכנס לאוסף, הוא הראשון שייצא – FIFO).
• Stack – מייצג אוסף של פריטים במחסנית (האחרון שנכנס לאוסף, הוא הראשון שייצא – LIFO).

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

1. ביצועים – שימוש באוספים הנ"ל יכול לגרום לביצועים נמוכים כאשר אנו מכניסים לאוסף טיפוסים מסוג struct בשל הפעולות בזיכרון המתבצעות בזמן ריצה ע"י המנגנונים של Net. (בתהליך הנקרא boxing שבו מתייחסים ל- value-type כגון struct כ- reference type). כלומר, פגיעה במהירות זמן הריצה של התוכנית.
2. המרות – האוספים הרגילים אינם סוגים בטוחים (Typed-Safe) מיכוון שהם עובדים עם מחלקת Object. זה אומנם מקנה להם את היכולת להכיל כל טיפוס אך מנגד יוצר בעיה שהאוסף יכול לקבל טיפוסים שאנחנו לא רוצים שיהיו בו. וכמובן שכל שליפה של פריטים מהאוסף תאלץ אותנו להשתמש בהמרות מיותרות. הפיתרון הנהוג היה ליצור מחלקות אוסף משלנו ולממש אותם לטיפוס מסויים - פיתרון שמצריך המון עבודה.

וכאן נכנס לתמונה השימוש ב- Generics (הקיים החל מגירסה 2 של .Net): שימוש באוספים גנריים.

לכל האוספים הקלאסיים המוזכרים לעייל יש גירסה גנרית שניתן להשתמש בה. האוספים נמצאים ב- namespace הנקרא System.Collections.Generic (מופיע כברירת מחדל ב- using בראש של כל קובץ C# החל מגירסה 2).

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

לדוגמא, על-מנת ליצור אוסף גנרי דינמי (המסוגל לגדול/לקטון בהתאם לצורך) המתנהג כמו האוסף הקלאסי ArrayList אך ללא החסרונות שציינו, ניתן להשתמש באוסף הגנרי <>List  :

List<int> numbers = new List<int>(); 

בדוגמא הנ"ל בחרנו לאסוף מספרים שלמים (int). כמובן שניתן לאסוף כל טיפוס נתונים שנרצה.

האוסף מכיל את כל הפונקציונליות הרלוונטית (הוספה/הסרת פריטים, פונקציות שירות כמו מיון וכו'):

List<int> numbers = new List<int>();
 
numbers.Add(500);
numbers.Add(-25);
numbers.Add(17);
 
numbers.Sort();
 
Console.WriteLine("The numbers (After a Sort):");
foreach (int n in numbers)
  Console.WriteLine(n);
 
Console.WriteLine("Count: {0} numbers", numbers.Count);

הפלט:

נציגים (delegates) ואירועים (events) הינם נושאים מאד מרכזיים בעבודה ב- NET. . הם מאפשרים למפתח לבנות רכיב בלי להגביל את מי שמשתמש בו לפעולות מסוימות.

delegate הוא טיפוס המצביע על פונקציה.

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

להלן דוגמא שננתח אותה מיד:

namespace Delegates
{
  delegate int Calc(int x, int y);
 
  class Program
  {
    static int Add(int a, int b)
    {
      return a + b;
    }
 
    static void Main(string[] args)
    {
      Calc c= new Calc(Add);
      int result = c(4, 6);
 
      Console.WriteLine(result);
    }
  }
}

הגדרת delegate מתבצעת באמצעות המילה השמורה delegate ולאחריה חתימה של פונקציה, כאשר שם "הפונקציה" הוא למעשה שם ה- delegate.

להלן הגדרת delegate בשם Calc:

delegate int Calc(int x, int y);

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

להלן דוגמא להצבעה על פונקציה בשם Add:

Calc c = new Calc(Add);

בכדי להפעיל את הפונקציה דרך ה- delegate יש להתייחס למשתנה שיצרנו כאילו הוא שם הפונקציה. בדוגמא שלהלן יודפס 10 (הסכום של 4,6):

int result = c(4, 6);
Console.WriteLine(result);

Multicast delegate

delegate יכול להצביע גם על מספר פונקציות, ניתן לעשות זאת באמצעות האופרטור =+ לדוגמא:

namespace Delegates
{
  delegate int Calc(int x, int y);
 
  class Program
  {
    static int Add(int a, int b)
    {
      Console.WriteLine("Add");
      return a + b;
    }
 
    static int Sub(int a, int b)
    {
      Console.WriteLine("Sub");
      return a - b;
    }
 
    static void Main(string[] args)
    {
      Calc c;
      c = new Calc(Add);
      c += new Calc(Sub);
      int result = c(4, 6);
 
      Console.WriteLine(result);
    }
  }
}

בפלט התוכנית ניתן לראות שהופעלו 2 הפונקציות אך התשובה שהוחזרה היא התשובה של הפונקציה האחרונה שהופעלה:

עד כאן הבנו איך יוצרים ומשתמשים ב- delegate להלן דוגמא הממחישה למה צריך delegate (מיד ננתח אותה):

namespace SortWithDelegate
{
  public delegate int CompareDeleg(int a, int b);
 
  class Program
  {
    static int[] arr;
 
    static int CompareAsc(int x, int y)
    {
      return x - y;
    }
 
    static int CompareDesc(int x, int y)
    {
      return y - x;
    }
 
    static void Sort(CompareDeleg compareMethod)
    {
      for (int i = 0; i < arr.Length - 1; i++)
        for (int j = i + 1; j < arr.Length; j++)
          if (compareMethod(arr[i], arr[j]) > 0)
            Replace(i, j);
    }
 
    private static void Replace(int i, int j)
    {
      int tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
    }
 
    static void PrintArr()
    {
      foreach (int num in arr)
        Console.Write(num + ",");
 
      Console.WriteLine();
    }
 
    static void Main(string[] args)
    {
      arr = new int[] { 123, 200, -63, 2, 7612, -13, 8 };
      Console.WriteLine("Orginal nuumbers:");
      PrintArr();
 
      Sort(new CompareDeleg(CompareAsc));
      Console.WriteLine("\nAscending order:");
      PrintArr();
 
      Sort(new CompareDeleg(CompareDesc));
      Console.WriteLine("\nDescending order:");
      PrintArr();
    }
  }
}

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

הרעיון הוא שהפונקציה Sort תקבל את המערך ו- delegate בשם CompareDeleg שיטפל בצורת המיון, כך שהפונקציה לא תגביל לסוג מיון מסוים אלא תיתן למי שמפעיל אותה לקבוע את סוג המיון.

ה- delegate בנוי כך שהוא מקבל שני מספרים (int) ומחזיר מספר המייצג מי יותר גדול בצורה הבאה:

• מספר חיובי – המספר הראשון יותר גדול
• מספר שלילי – מספר השני יותר גדול
• אפס – המספרים שווים

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

• CompareAsc – למיון עולה
• CompareDesc – למיון יורד

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

Attributes הן תכונות שניתן לתת לאלמנט תכונתי כלשהו כגון: מחלקה, פונקציה, assembly ועוד. התכונה הינה למעשה מידע נוסף שאנו מספקים לאלמנט אשר בד"כ גורר אחריו התנהגות כלשהי. בשלב זה נכיר את התחביר ונלמד על מספר attributes פשוטים כאשר בהמשך נלמד על סוגים רבים של attributes בנושאים הרלוונטיים.

כל attribute שניצור וכל attribute שכבר קיים ב-NET., הוא למעשה מחלקה (class) היורשת בצורה ישירה או עקיפה ממחלקה הנקראת Attribute.

את ה- attribute נכתוב באמצעות סוגריים מרובעים מעל האלמנט אליו נרצה לשייך אותו:

[AttributeName] 
Some element

לדוגמא, attribute בשם Obsolete מעל הפונקציה Print:

[Obsolete]
static void Print()
{
  Console.WriteLine("Print");
}

ניתן להעביר פרמטרים ל- attribute במידה והוא מקבל לדוגמא:

[Obsolete("This method is obsolete, please use other method")]
static void Print()
{
  Console.WriteLine("Print");
}

כשנקמפל את הפרויקט נקבל את האזהרה הבאה:

דוגמא נוספת ל- attribute:

כאשר נרצה לתת attribute ל- assembly נכתוב זאת בקובץ AssemblyInfo.cs שנמצא בספריה Properties שבפרויקט ונעשה זאת כך:

[assembly: AssemblyTitle("MyApplication")]

AssemblyTitle מייצג כותרת ל- assembly שתוצג במאפייני הקובץ במערכת ההפעלה.

ב- #C ניתן להעמיס פונקציות, בנאים ואופרטורים.

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

התחביר להעמסת אופרטורים מתחלק ל- 2 סוגים:

• אופרטור אונרי (Unary) – הפועל רק על אופרנד אחד, כגון ++a
• אופרטור בינארי (Binary) – הפועל על 2 אופרנדים, כגון a+b

העמסת אופרטור אונרי:

    public static Circle operator ++(Circle c)
    {
      //מימוש      
    }

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

1. public static
2. הערך המוחזר (Circle בדוגמא הנ"ל)
3. מילת המפתח operator
4. האופרטור שרוצים להעמיס (++ בדוגמא)
5. פרמטר מטיפוס המחלקה ( Circle c בדוגמא)

העמסת אופרטור בינארי:

    public static Circle operator +(Circle c, int x)
    {
      //מימוש      
    }

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

1. public static
2. הערך המוחזר (Circle בדוגמא הנ"ל)
3. מילת המפתח operator
4. האופרטור שרוצים להעמיס (++ בדוגמא)
5. פרמטר מטיפוס המחלקה Circle c)בדוגמא)
6. פרמטר נוסף, מטיפוס כלשהו (int x בדוגמא)

לדוגמא, מימוש האופרטור ++ (אונרי) והאופרטור + (בינארי) במחלקה Circle:

class Circle
  {
    public double Radius { get; set; }
 
    public static Circle operator ++(Circle c)
    {
      c.Radius++;
      return c;
    }
 
    public static Circle operator +(Circle c, int x)
    {
      Circle newC = new Circle();
      newC.Radius = c.Radius + x;
      return newC;
    }
  }

שימוש באופרטורים:

  class Program
  {
    static void Main(string[] args)
    {
      Circle c = new Circle() { Radius = 10 };
 
      c++;
      Console.WriteLine(c.Radius);
 
      c = c + 5;
      Console.WriteLine(c.Radius);
    }
  }

פלט התוכנית:

האופרטורים הניתנים להעמסה:

האופרטורים שלא ניתנים להעמסה:

כללים להעמסת אופרטורים

• מוגדרים תמיד כ- public static
• העמסה של אופרטור השוואתי (לוגי) מחייבת העמסה של האופרטור המנוגד (כולל true,false). לדוגמא, העמסה של == תחייב העמסה גם של =!
• העמסה של אופרטור השוואתי תחזיר ערך בוליאני בלבד
• העמסה של אופרטורים ==, =! מחייבים מימוש הפונקציה Equals ופונקציה זו מחייבת מימוש הפונקציה GetHashCode
• בכדי למנוע בילבול לא מומלץ לשנות את המשמעות המקורית (והמובנת) של האופרטור

העמסת casting

ניתן להעמיס גם את האופרטורים המבצעים casting בין טיפוסים. לדוגמא נרצה לאפשר המרה בין string ל- Circle ובחזרה, ובין double ל- Circle ובחזרה.

תזכורת:

• explicit casting – המרה מפורשת שבה חובה לבצע כתיבת ה- casting
• implicit casting – המרה מרומזת ללא צורך בכתיבת ה- casting

מימוש המרות מפורשות (explicitly casting) – 

• המרה מפורשת מ- string ל- Circle :

    public static explicit operator Circle(string str)
    {
      Circle c = new Circle();
      c.Radius = double.Parse(str);
      return c;
    }  

• המרה מפורשת מ-double ל- Circle :

    public static explicit operator Circle(double dbl)
    {
      Circle c = new Circle();
      c.Radius = dbl;
      return c;
    }

מימוש המרות מרומזות (implicitly casting) - 

• המרה מרומזת מ- Circle ל- string:

    public static implicit operator string(Circle c)
    {
      return c.Radius.ToString();
    }

• המרה מרומזת מ- Circle ל- double:

    public static implicit operator double(Circle c)
    {
      return c.Radius;
    }

שימוש:

   static void Main(string[] args)
    {
      string str = "9";
      //explicitly convert String to Circle:
      Circle c1 = (Circle)str;
      Console.WriteLine(c1.Radius);
 
      double dbl = 7;
      //explicitly convert Double to Circle:
      Circle c2 = (Circle)dbl;
      Console.WriteLine(c2.Radius);
 
      c1 += 10;
      str = c1; //implicitly convert Circle to String
      Console.WriteLine(str);
 
      c2 += 10;
      dbl = c2; //implicitly convert Circle to Double
      Console.WriteLine(dbl);
    }

פלט התוכנית: