מחלקות אוסף, סדרנים ושיטות אנונימיות ב#C

[eido300]

למדתי על כמה "מחלקות אוסף" ב#c ואת queue ו-stack לא הבנתי,אשמח אם תסבירו לי מה הרעיון שלהם ואיך עובדים איתם.

סדרנים זה בעצם מערך של מאפיינים? ומה עושים עם האופרטורים shift ו-bitwise?

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

תודה.

[שניצל]

stack (מחסנית) ו-queue (תור) הם שני מבני נתונים הדומים לרשימה, עם מגבלה על איפה אפשר להכניס ולהוציא איברים מהם.

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

לתור אפשר להכניס איברים מצד אחד, ולהוציא מהצד השני (תחשוב על תור של אנשים).

אתה יכול לקרוא עוד על זה בויקיפדיה:

http://he.wikipedia.org/wiki/%D7%9E%D7%97%D7%A1%D7%A0%D7%99%D7%AA_(%D7%9E%D7%91%D7%A0%D7%94_%D7%A0%D7%AA%D7%95%D7%A0%D7%99%D7%9D)

http://he.wikipedia.org/wiki/%D7%AA%D7%95%D7%A8_(%D7%9E%D7%91%D7%A0%D7%94_%D7%A0%D7%AA%D7%95%D7%A0%D7%99%D7%9D)

מה זה סדרנים? Indexer? זה פשוט נותן לך להגדיר גישה לאובייקט שלך באמצעות סוגריים מרובעים, כמו שניגשים למערך. ההגדרה של Indexer היא דומה לזו של Property, ומותר לך לממש אותו איך שבא לך. אתה יכול לקרוא עוד כאן:

http://msdn.microsoft.com/en-us/library/vstudio/6x16t2tx.aspx

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

לגבי השימושים של bitwise operators, אתה יכול לקרוא כאן:

http://en.wikipedia.org/wiki/Bitwise_operation#Applications

בתכל'ס זה כשאתה צריך להתייחס ל-int כאל אוסף של ביטים ולא כמספר אחד (לדוגמה כל ביט יכול לייצג משהו אחר), או לדוגמה כשאתה רוצה לבצע המרות בין int (שהוא 32 ביטים) לארבעה בתים (שהם 8 ביטים כל אחד).

לגבי שיטות אנונימיות: לא כל כך ברורה לי השאלה. יש כאן מדריך בנושא:

http://msdn.microsoft.com/en-us/library/0yw3tz5k.aspx

מומלץ שתקרא קודם גם על Delegates:

http://msdn.microsoft.com/en-us/library/ms173171.aspx

(שים לב ללינקים ב-"In This Section", הם יסבירו לך עוד על הנושא)

[eido300]

אוקיי, אני יעבור על זה.

תודה רבה

- - - תגובה אוחדה: - - -

לגבי הstack, queue והbitwise operators למה צריכים אותם?

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

ושיטות אנונימיות (אם הבנתי נכון) באות כדי כביכול לתאם בין שיטה לבין נציג שהחתימות שלהם לא זהות.

והתחביר שלהם הוא כזה:

delegate(parametr list){code};

ומה זה משפט למבדה?

[שניצל]

Queue ו-Stack: נתתי לך לינקים לויקיפדיה. שניהם שימושיים באלגוריתמים מסויימים (לדוגמה מעבר על עץ או גרף).

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

Indexer: אין שום בעיה להגדיר מערך של כל טיפוס, לא חייבים פרימיטיביים. אתה יכול גם להגדיר מערך של String או מערך של Object. ה-Indexer נותן לך להגדיר למחלקה שלך גישה שדומה (מבחינת השימוש בה) לגישה למערך, כלומר באמצעות סוגריים מרובעים. כמו שאמרתי קודם, ה-Indexer הוא פונקציה לכל דבר (ליתר דיוק זוג פונקציות - get ו-set - אבל לא חייבים לממש את שתיהן) ולכן אתה יכול לממש אותו איך שבא לך.

שיטות אנונימיות: ממש לא. קודם כל תקרא ותבין מה זה Delegates:

http://msdn.microsoft.com/en-us/library/ms173172.aspx

(שים לב שבמאמר הזה אין התייחסות עדיין לשיטות אנונימיות, זה יהיה בהמשך)

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

אחרי שתבין את נושא ה-Delegates ושיטות אנונימיות תוכל גם ללמוד על למבדא.

[eido300]

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

ולגבי indexer אם אפשר לבנות מערך גם של סוג שאנחנו יצרנו אז למה צריך את הindexer?

[שניצל]

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

Delegate זה דרך להגדיר משתנה שמייצג פונקציה (מה שנקרא גם "מצביע" לפונקציה). באמצעות Delegates אתה יכול להעביר פונקציה כלשהי כפרמטר לפונקציה אחרת.

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

List<string> Filter(List<string> input) {
  List<string> result = new List<string>();
  foreach (string s in input) {
    if (s.Length % 2 == 0) {
      result.Add(s);
    }
  }
  return result;
}

שים לב שאפשר להחליף את הקריטריון s.Length % 2 == 0 בקריטריון אחר - לדוגמה, שהמחרוזת תתחיל באות "a" או תסתיים באות "b".

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

static bool IsOddLength(string s) {
  return (s.Length % 2 == 0);
}

או ככה:

static bool StartsWithA(string s) {
  return s[0] == 'a';
}

המשותף לפונקציות האלה הוא החתימה שלהן - שתיהן מקבלות string ומחזירות bool. את החתימה הזו אפשר לייצג ע"י Delegate, שנראה כך:

public delegate bool Predicate(string s);

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

Predicate func;
func = IsOddLength;

עכשיו func הוא בעצם "מצביע" לפונקציה IsOddLength, ואפשר להפעיל אותו בדיוק כמו שהיית מפעיל את IsOddLength. אז עכשיו אפשר לממש את הפונקציה Filter הנ"ל ככה:

List<string> Filter(List<string> input, Predicate pred) {
  List<string> result = new List<string>();
  foreach (string s in input) {
    if (pred(s)) {
      result.Add(s);
    }
  }
  return result;
}

ועכשיו אם לדוגמה אני רוצה להפעיל את הפונקציה הזו, אני יכול לקרוא לה ככה:

List<string> myList = new List<string>();
// .... fill the list somehow ...
List<string> filtered = Filter(myList, IsOddLength);

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

List<string> filtered = Filter(myList, delegate (string s) { return s.Length % 2 == 0; });

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

Indexer זה סה"כ זוג שיטות, בדיוק כמו ש-Property זה זוג שיטות. בדיוק כמו כל שיטה אחרת שאתה יכול להגדיר. היא יכולה לעשות מה שבא לך. אתה יכול לממש אותה איך שאתה רוצה. היא נותנת לך לבנות מחלקה שמדמה התנהגות של אוסף כמו מערך - כמו List וכמו Dictionary. הנה דוגמה לשימוש ב-Dictionary:

Dictionary myDictionary = new Dictionary(); 
myDictionary["Hi"] = "Bye!"; 
System.Console.WriteLine("The dictionary value for Hi is: {0}", myDictionary["Hi']);

רואה את הגישה למילון באמצעות הסוגריים המרובעים? זה בעצם מפעיל את ה-Indexer של ה-Dictionary.

[eido300]

נציג=delegate ע"פ הספר ל#C יש נציגים ול++c יש מצביעים הם דומים, פרט לעובדה שנציג יכול להפנות רק לשיטה שדומה לו בחתימה.

שיטה מתאמת= adapter.

תודה על כל התשובות.

[שניצל]

באיזה ספר מדובר?

[eido300]

באיזה ספר מדובר?

סדנת לימוד visual c# 3.0.

הספר במקור הוצא ע"י מייקרוסופוט (המחבר הוא ג'ון שארפ אבל מייקרוסופוט הוציאו) ואת התירגום לעברית הוציאו הוד עמי.

זה הספר.