מערכת פקודות

[ASP zone]

מערכת פקודות

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

 

[ייוניי]

נשמע קצת כללי

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

 

[ASP zone]

יש אירועים מסויימים

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

 

[שלמה שוורץ]

בקצב הזה לא נתקדם

אילו אירועים? איזה שפה? איזו סביבה? איזה אובייקטים? מה אתה רוצה?

 

[ייוניי]

ניחוש

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

 

[ASP zone]

תראה זה ככה

יש לי משתנה מסויים מסוג int בתוך מחלקה A הבעיה היא שאם הוא משתנה אז אני צריך לשנות אלף ואחת דברים במחלקה B וC וכו... עכשיו איך אני יעשה שהוא ישנה אותם? מה יהיה הטריגר? איך אפשר לתכנת דבר שיאזין בreal time? השפה היא CPP אגב.

 

[ייוניי]

הטריגר לשינוי בערך של משתנה פרטי

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

 

[ASP zone]

איך אפשר לעשות את זה בrealtime?

 

[עידו פ]

ה-pattern של observer אכן מתאים כאן

כפי שייוניי ציין. אתה יכול לקרוא יותר פרטים כאן: http://www.dofactory.com/Patterns/PatternObserver.aspx במקרה שלך, אני מניח שהמחלקה A תהיה זו בעלת יכולות ה-observer. כמובן שפתרון זה אפקטיבי יותר במקרים בהם לא ידוע כמה אובייקטים תלויים ב-A. אם ידוע לך שרק B ו-C תלוים ב-A ואין הגדרה שאומרת שיתכן שיהיו עוד אובייקטים, אין חובה להשתמש ב-Pattern כללי כגון ה-observer, אלא ניתן לנהל במחלקה A את המשתנה הפנימי כך ששינוי שלו פשוט יפעיל את המתודות הנדרשות ב-B וב-C. לגבי ה-"real time" - במקום לעשות ניהול מסובך, למה לא לעטוף את המשתנה הפנימי במתודה שאחראית לעדכן אותו (מתודות Get/Set). מתודות אלו יהיו אחראיות על העדכון של המשתנה ועל ההתראה למחלקות האחרות על כך שמשהו קרה למשתנה.

 

[ASP zone]

זה לא רק בB וC

זה תלוי בID שנמצא בA. יש Get וSet כבר. אבל השאלה היא איך אני ניגש לשם.

 

[עידו פ]

שאלת הבהרה

איך היית מגדיר את ה"רצונות" של הישויות ? האם A "רוצה" לעדכן את המחלקות התלויות בו (B ו-C) או שמא המחלקות התלויות "רוצות" לדעת כש-A מתעדכן ? אם המקרה הראשון, אני לא רואה בעיה בלממש את עדכון B ו-C (או E ו-F) כחלק מתהליך ה-SET של המשתנה (מן הסתם מומלץ לחלק נכון את המתודות כדי לשפר תחזוקה). אם המקרה השני, כדאי להשתמש בסגנון observer כך שכאשר B ו-C (או E ו-F) נוצרים הם רושמים את עצמם ל-A וכאשר A מתעדכן הוא מידע אותם לגבי הערך העדכני.

 

[ASP zone]

A רוצה לעדכן את B וC

אני לא הבנתי כל כך את הpattren ההוא. אתה יכול להסביר לי אותו בבקשה.

 

[עידו פ]

ראשית כל

יש בקישורים לינק לאתר העוסק ב-DP ושם יש הסבר מפורט. הסבר קצר - הרעיון של Observer הוא שיש מחלקה אחת אליה נרשמים אובייקטים שרוצים לדעת כשקורה משהו. כל האובייקטים שנרשמים צריכים לממש ממשק מסוים, על-מנת שהמחלקה של ה-observer תדע להפעיל אותם (לחילופין, פתרון ++C יכול להיות ע"י שליחת האובייקט ומצביע למתודה שיש להפעיל כשקורה משהו). האחריות של מחלקת ה-observer היא לנהל את האובייקטים שנרשמים אליה, וכאשר קורה מה שקורה, לעבור על כל אחד מהם ולהפעיל את המתודה שהוגדרה בממשק. במקרה שלך, מחלקה A יכולה לרשת מ-observer ומחלקות B ו-C יממשו את הממשק על-מנת שניתן יהיה להפעיל אותן.

 

[ייוניי]

עדיין לא הבנתי מה בדיוק הבעיה...

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

 

[ASP zone]

הגישה בין A ל B וC

הם בכלל לא נמצאים באותה מחלקה...

 

[ייוניי]

עכשיו העניין מתבהר!

אז עכשיו אני אשאל אותך: האם הקשר בין A לבין B ו-C נקבע בזמן היצירה של A? אם כן, שלח את B ו-C ב Ctor של A ושמור אותם במשתנים פרטיים. האם הקשר בין A לבין B ו-C איננו קבוע? אם כך אולי אפשר להשתמש באובייקט מתווך עם מתודות getB ו- getC, ולשלוח אותו ב Ctor של A. (למרות שאם השינויים הצפויים ב B ו-C דומים אולי עדיף לקרוא למתודה על האובייקט המתווך ולסמוך עליו שיעביר את ההודעה ל B ו- C).

 

[ASP zone]

הקשר נוצר בזמן היצירה

ואי אפשר לשים את B וC בA.

 

[ייוניי]

אי אפשר?

אפשר לשאול למה אי אפשר?

 

[ASP zone]

כי אי אפשר להעביר פוינטרים לזה

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

 

[עידו פ]

עדין נשמע לי ש-observer זה הפתרון

אם גם B וגם C יממשו את ה-Interface ש-Observer מגדיר, לא תהיה בעיה לרשום אותם (וכל מחלקה אחרת שתממש את ה-interface) ב-A או באיזשהי מחלקת observer שתגדיר. אפשרות אחרת היא להשתמש ב-RTTI (אמרת שאתה עובד ב-++C אז אתה אמור להכיר את זה), אבל זה סתם יראה מגעיל, אז אולי לא כדאי לעשות את זה.