קראתי את זה בספר של corner באתר corner.co.il ולא הבנתי, אשמח אם תסבירו לי מה זאת אומרת שיטות משוב?

ומה זה השם הזה callback function למה השם הזה בדיוק?

על איזו שפה מדובר?

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

c# זה השפה, מה שאתה אומר זה שאני יוצר פונקציה למשל שעושה לי משהו, וברגע שאני לוחץ על כפתור ונוצר לי click event אז מופעלת לי פונקציה על ידיי delegate?

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

delegate זה משתנה שמכיל רפרנס לפונקציה. במקרה של callback function ה-delegate יכול להכיל רפרנס לאותה פונקציה (שיכולה להיות אנונימית)

זה מדריך נחמד לנציגים (delegate).

גם זה אחד טוב.

נ.ב. תמיד יש גם את גוגל, חיפוש פשוט יכול מאוד לעזור לך לדוגמא במקרה הזה חיפוש המילים c# delegate מביא תוצאות מאוד מעניינות.

באופן כללי, אם אובייקט א' מכיל רפרנס לאובייקט ב', אז א' יכול לקרוא לפונקציות של ב'. אבל מה אם א' רוצה ש-ב' יוכל להתריע ל-א' על אירועים שקרו לו? לדוגמה - אם ב' היא מחלקה שמייצגת את המקלדת, ואנחנו רוצים שהיא תתריע כשנלחץ מקש כלשהו, או אם ל-ב' יש פונקציה שלוקחת הרבה זמן, ואנחנו רוצים להתריע כאשר היא מסתיימת? אז בשביל זה יש callback function - א' מעבירה ל-ב' רפרנס לפונקציה של א', ש-ב' תקרא לה מתי שצריך.

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

Design Pattern? אף פעם לא הבנתי את המושגים האלה

למה נתנו לו את השם הזה ? אשמח שמישהו יסביר לי למה השם הזה בכלל ניתן לו, לפעמים אני מסתבר עם השמות ואז זה גורם לי לא להבין את כל המכלול

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

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

בצורה הכי פשוטה אני לא מבין למה אני צריך פוינטר לפונקציה, למה לא פשוט להשתמש בפונקציה וזהו

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

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

למה הcomplex הזה?

נערך 2014 במאי 711 שנים על-ידי bdoron

תמשיך ללמוד על event ואז תבין למה צריך delegates.

(יש עוד שימושים, אבל זו הייתה המטרה העיקרית שלשמה זה הומצא ב-#C).

עזוב אותך מ-design pattern, זה מושג מתקדם יותר. קודם כל תסיים ללמוד את הבסיס של תכנות מונחה עצמים.

נערך 2014 במאי 711 שנים על-ידי שניצל

יואב, אני יוצא מדעתי אני מבין דלגייטים אבל אני לא מבין למה אני צריך להשתמש ב2זה

למה לא להשתמש ישירות בפונקציה

למה לא להשתמש ישירות בפונקציה

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

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

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

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

אז מה הפתרון שימנע את כל שכפול הקוד הזה? delegates!

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

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

למשל יכול להיות שמשתמש A ירצה להוסיף פקטור מסויים לכל ערך (נניח בונוס 5 נקודות לכל ציון). משתמש B למשל ירצה לקחת כל ערך שמייצג רדיאנים ולהמיר אותו למעלות.

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

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

למה לי להשתמש בדלגייט ולא בפונקציה רגילה

מה הקטע ?

אתה בכוונה מתעלם מההודעות שלי? כתבתי לך דוגמה ארוכה ומפורטת שמסבירה איפה יש שימוש ב-delegates.

סורי יואב לא ראיתי את ההודעה שלך ...

בכל אופן אני לא מבין

אתה לא תמיד יודע מראש מהי הפונקציה

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