Properties של Class
public, אפשר להכניס לו מחיר שלילי והערך נשמר באובייקט. בדיבאגר רואים את המינוס 10 בזיכרון.private בשם באות קטנה, למשל price, כי לא נהוג שמשתנים פרטיים יתחילו באות גדולה.Price, ובתוכו בלוק set ובלוק get. בתוך ה-set המילה value מכילה את הערך שנשלח מבחוץ, ורק אם value >= 0 הוא נשמר בשדה.firstProduct.Price = -10 או קוראים firstProduct.Price, ו-.NET מפעיל את ה-set או ה-get אוטומטית.set וה-get מבטלים את הסימון באפשרות Step over properties בתפריט Tools > Options > Debugging.get בלבד, למשל מחיר כולל מע"מ שמחושב מהמחיר, ואי אפשר להציב בו ערך.set בלבד, למשל מדפסת שמקבלת מסמך להדפסה, בלי שאפשר לקרוא ממנה מידע.פרקי ההרצאה: Properties של Class
תמלול ההרצאה: Properties של Class
הטקסט המלא של הדקות הראשונות בהרצאה «Properties של Class» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו ראינו באחד הסרטונים הקודמים ש-Object Oriented בנוי משלושה אבני בניין Incapsulation זה היכולת לבנות ישות סגורה, כלומר Class Inheritance זה היכולת לרשת את כל התכונות של ישות אחת לישות אחרת ו-Polymorphism שזה בעצם שינוי התוכן של פונקציה ממחלקת בסיס למחלקה שיורשת בשניים שלושה סרטונים האחרונים בעצם ראינו
איך אנחנו בונים קלאס מושלמת ואנחנו בנינו קלאס פרודקט ולקלאס פרודקט שבנינו יש data member כלומר משתנים ויש פעילויות שנבנו על ידי פונקציות אז נראה שבעצם סיימנו את הקונספט של encapsulation ושל בניית ישות אבל למעשה לא ממש סיימנו כי Object Oriented מציעה עוד הרבה כלים
מגוון כלים שמאפשרים לעשות את הישות שלנו יותר חזקה תכף אנחנו נראה מה זה בדיוק אומר יותר חזקה אבל בסרטון הזה ובמהלך הסרטונים הבאים אנחנו הולכים לראות מספר כלים נוספים שקיימים בשפת Object Oriented בכדי להעצים את היכולות של הישות ורק אחרי שנסיים את הכלים האלה של איך להעצים יכולות של ישות ולעשות אותה קצת
יותר טובה אז אנחנו רק נעבור לכלי הבא שנקרא הורשה כל כלי נוסף שאנחנו הולכים לראות יהיה בסרטון נפרד ובסרטון הזה מה שאנחנו הולכים לראות זה משהו שנקרא פרופרטי וישנו הבדל גדול בין דאטה ממבר שהוא בעצם משתנה ברמת המחלקה לבין משהו שנקרא פרופרטי למה אנחנו צריכים להבין מה זה פרופרטי כי אנחנו תכף נראה שזה בעצם מגן על המידע שלנו ומונע שגיאות
אבל בשביל להבין מה זה ולמה אנחנו צריכים את זה בואו קודם כל נבין איזשהו חוק מאוד בסיסי בנוגע לפיתוח באובג'קט אוריינטד והחוק הזה בעצם מתחלק לשני חוקים שונים חוק ראשון אומר שאנחנו צריכים לסגנן לעצמנו איזשהו view point כלומר איזושהי נקודת מבט שאומרת שבאבג'קט אוריינטד קיימים שני מתכנתים למה קיימים שני מתכנתים
מפני שכאשר כותבים קלאס זה אומר שישנו מתכנת א' שכותבת הקלאס ולאחר מכן ישנו מתכנת ב' שמשתמש בקלאס וכמובן יוצר ממנה אובייקט ומשתמש באובייקט. הוא יכול ליצור אובייקט אחד או יותר.
בדוגמה הזאת אנחנו רואים שיצרנו שני אובייקטים מקלאס product. עכשיו, ברור שבמציאות אנחנו יכולים לכתוב את המחלקה וחמש דקות אחרי זה להשתמש איתה.
אבל ה-viewpoint שאנחנו צריכים לסגל לעצמנו זה שזה שני מתכנתים שונים. למה אנחנו צריכים לחשוב כך? מפני שא', יכול להיות שזה באמת שני מתכנתים שונים.
ב', גם אם אנחנו עכשיו המתכנת היחיד, יכול להיות שבהמשך יבוא מתכנת אחר וישתמש במחלקה שאנחנו כותבים. ויכול להיות שאנחנו נשתמש בה אחר כך וטיפה נשכח איך בדיוק להשתמש בה.
אז החוק הראשון אומר, יש שני מתכנתים, מתכנת א' וזה שבונה את הקלאס, מתכנת ב', ולאחר מכן הוא משתמש בקלאס. החוק הבא שאנחנו צריכים להבין זה שאנחנו מתכנת א', אנחנו יודעים טוב מאוד מה אנחנו עושים אבל מתכנת ב' זה שמשתמש בקלאס הוא לא
בדיוק יודע איך להשתמש נכון עם הקלאס. אפשר להגיד שמתכנת א' הוא מתכנת טוב ומתכנת ב' הוא לא מתכנת כל כך טוב והנקודת מבט הזאת גורמת לנו לבנות את הקלאס שלנו בצורה חזקה יותר.
למה? כי אם מתכנת ב' מבחינתנו הוא לא מתכנת כל כך טוב אנחנו אנחנו צריכים לחשוב על ה-Worst Case, על המקרה הגרוע ביותר, שמתכנת ב' לא יודע בדיוק איך להשתמש בקלאס שלנו, והולך להשתמש בו בצורה לא נכונה, ויכול אכן להכניס בתוך המשתנים שלנו מידע שגוי.
עכשיו, אם אנחנו מבינים את שני העקרונות האלה, שיש שני מתכנתים, אנחנו מתכנת א' שכותבים את המחלקה ומישהו אחר משתמש בה, ועוד הבן אדם הזה לא יודע איך להשתמש במחלקה נכון, או שיכול לטעות ולהכניס לנו מידע שגוי, כאן מגיע עיקרון נוסף שאנחנו צריכים להבין, וזה שהמחלקה שאנחנו
בונים צריכה להגן על המידע שיש לה. מה זה המידע שיש לה? המידע שיש לה זה לא הפונקציות, כי אלו בעצם הפעילויות, הדברים שהיא יודעת לעשות.
המידע שיש למחלקה זה ה-data members שנמצאים בתוכה. בסופו של דבר ה-data members האלה הולכים להיות משתנים באובייקט שהולך להיפתח מהמחלקה, ומי שמשתמש במחלקה הוא זה שיוצר את האובייקט והוא זה שהולך להכניס ערכים לתוך הדאטה ממברס ולכן הוא יכול להכניס ערכים שגויים והמחלקה צריכה להגן על הערכים שלה לפי מה
שהיא מוצאת לנכון. אז בואו נראה מה הכוונה. אנחנו רואים כאן את שני הקבצים יש לנו פה את המחלקה ויש פה את הקוד שמשתמש בה ובוא נניח שמי שבנה את המחלקה שזה בעצם אנחנו סיימנו לבנות אותה וכעת מתכנת ב' הולך להשתמש במחלקה ומה שמתכנת ב' הולך לעשות זה את הקוד הבא הוא הולך להגיד
דבר כזה לתוך product name הוא הולך להכניס אפל לתוך category name הוא הולך להכניס פרוץ ולתוך price הוא הולך להכניס מינוס 10 בואו נמחק את כל הקוד הנוסף וכבר אנחנו מבינים שיש פה איזושהי בעייתיות מפני שמה זה בדיוק מינוס 10 עבור מחיר?
אז בואו נניח שמבחינתנו כאשר אנחנו בונים את המחלקה מחיר אמור להיות לפחות 0 אם לא חיובי. זאת אומרת, לא יכול להיות מחיר שלילי, זה לא הגיוני.
מבחינתנו זה מידע שגוי. השאלה עכשיו אם הקוד שכתוב פה יהיה חוקי מבחינת התוכנית ואם אכן יהיה מינוס 10 בתוך המחיר.
בואו נריץ את זה ונסתכל שאכן בתוך האובייקט יושב לו מינוס 10 במחיר, זאת אומרת המחלקה הסכימה לקבל ערך שגוי עבור המחיר. בואו נריץ את זה בדיבאגר, נסתכל פיזית בתוך הזיכרון של האובייקט עם העכבר ונראה שיושב לו שם בנחת הערך מינוס 10 בתוך המשתנה הדאטה ממבר פרייס שנמצא באובייקט של המחלקה שלנו.
מי כאן טעה? אז אפשר להגיד ברור שמתכנת ב' זה שהשתמש במחלקה טעה כי הוא הכניס מינוס 10 ואסור להכניס מינוס 10. אבל למעשה אנחנו צריכים לצאת מנקודת הנחה שהוא לא יודע איך להשתמש במחלקה או שהוא לא הבין איך להשתמש בה או שהוא השתמש בה לא נכון.
ואפשר להגיד שמי שטעה כאן זה זה שכתב את המחלקה מפני שהוא לא כתב אותה מספיק חזקה בכדי להגן על הדאטה ממבר שיש לה מפני מידע שגוי. עכשיו מי שכותב את המחלקה יודע בדיוק מה היא מייצגת.
ואני כותב את המחלקה פרודקט, אני יודע שהיא מייצגת מוצר. לכן אני יודע מה כל data member מייצג, ולכן אני יודע מה זה אומר מחיר, ואני יודע שמחיר צריך להיות 0 ומעלה.
נניח שהמוצר ניתן בחינם, אז המחיר שלו הוא 0. אם הוא לא ניתן בחינם, המחיר שלו יהיה חיובי, אבל בחיים המחיר שלו לא יכול להיות שלילי.
אין דבר כזה מחיר שלילי למוצר מבחינתי. לכן אני צריך עכשיו לבצע משהו בתוך המחלקה בשביל להגן על אובייקטים ממנה מפני מידע שגוי כך שהבחורצ'יק הזה שמשתמש במחלקה לא יצליח להכניס בה מינוס 10. אז אפשר להגיד שבאבג'קט אוריינטד על המחלקה עצמה להגן על המידע שלה מפני שימוש שגוי והשאלה
היא איך אנחנו יכולים לעשות את זה הרי ברגע שהוא הגיע לפרייס אוטומטית הוא יכול להכניס מינוס 10 לפרייס. דבר ראשון מה שאנחנו הולכים לראות זה איך פתרו את הבעיה הזאת בשפות העתיקות, לא כל כך עתיקות אבל ישנות, כמו C++ וכמו Java.
לאחר מכן אנחנו הולכים לראות איזה כלי תכנותי שקיים בשפות יותר חדשות כמו C# או VB.NET. אז למעשה ב-C++ וב-Java מה שעשו בשביל לפתור את הסיטואציה הזאת זה השתמשו קודם כל בקונספט של הרשעת גישה.
אנחנו רואים שהרשעת הגישה של פרייס היא פאבליק ואנחנו צריכים להיזכר מה זה אומר פאבליק ואנחנו זוכרים שפאבליק אומר שכל אחד יכול לגעת במשתנה הזה גם המחלקה עצמה וגם אזור קוד שנמצא מחוץ למחלקה כמובן דרך אובייקט שקיים ואז מה שעשו ב-C++ אמרו דבר כזה קודם כל בואו לא ניתן הרשעת גישה
מלאה למשתנה הזה אלא נגדיר אותו כפרייבט עכשיו שימו לב שאוטומטית אנחנו מקבלים שגיאה על האזור שמנסה לגעת במשתנה וזה ברור מפני שהוא פרייבט.
אנחנו לא רוצים שיגשו אליו ישירות. הדבר הבא שאנחנו הולכים לעשות זה משתנים שהם פרייבט לא נהוג שהם יתחילו באות גדולה, אנחנו נדבר על זה טיפה בהמשך. בואו נשנה לפרייס עם פי קטנה רק בכדי שיהיה יותר הגיוני להשתמש במשתנה פרייבט עם פי קטנה.
בסדר, אבל עדיין זה לא עוזר לנו מפני שמי שמשתמש במחלקה לא יכול לגעת בפרייס ואנחנו כן רוצים שהוא יצליח להכניס ערך לתוך פרייס. אז מה שעשו ב-C++ ובג'אווה זה אפשרו לגשת למשתנה הזה על ידי שתי פונקציות.
פונקציה אחת נקראת בסלנג סטר והפונקציה הזאת יש לה הרשאת גישה public, היא לא מחזירה כלום והשם שלה זה set, זה מתחיל בסט ואז השם של המשתנה מאוד גדולה, זה מתחיל מאוד גדולה, לדוגמה סט פרייס.
פונקציית הסטר סט פרייס צריכה לקבל את הערך שאנחנו רוצים להכניס לתוך הדאטה ממבר. הטיפוס שלו זה דצימל ולכן אנחנו רושמים דצימל ובואו נקרא לו בשם אחר בשביל שלא יהיה כפילות שמות דה פרייס.
עכשיו על פונקציית הסטר לבצע בדיקה האם הערך דה פרייס שמישהו מנסה להכניס לנו הוא חוקי, מה זה אומר חוקי, גדול או שווה לאפס.
אם כן, רק אז אני מאשר אותו להכנסה עבור פרייס. פונקציה נוספת זה פונקציה שבסלנג נקראת getter. הפונקציה הזאת רק מחזירה את הערך של הdata member price כי הוא פרייבט ואין לנו שום אפשרות להגיע אליו אם בחוץ.
אוקיי, אז יש לנו פה public, decimal, הפונקציה מתחילה ב-get ואז השם שלה משתנה, והיא לא מקבלת כלום, וכל מה שהיא עושה זה return price.
כעת האזור שמשתמש במחלקה לא יכול להגיע בצורה ישירה לדאטה ממבר הפרטי price, כי חסמנו אותו, private, אבל יש לו שתי פונקציות, אחת בשביל להכניס מידע ואחת בשביל לקרוא מידע.
זאת אומרת שהאזור שמשתמש במחלקה כל מה שהוא צריך לעשות זה לקרוא כל האובייקט נקודה סט פרייס ואז לשלוח את אותו ערך שהוא רוצה במקרה הזה זה יהיה מינוס 10 אם הוא רוצה להציג את המידע אין לו שום בעיה לקרוא לגט פרייס בשביל לקבל את המידע ולראות אותו כאן אנחנו רואים שיש לנו פרינט אז כל הפרטים הולכים להיות מוצגים לנו אוקיי את זה אנחנו יכולים למחוק בואו נבדוק אנחנו מריצים ואנחנו רואים שהמחיר הוא 0 גם אם
אנחנו מגיעים אליו ישירות וגם אם אנחנו קוראים לפרינט בשביל לקחת אותו אז בואו נסתכל עם דיבאגר איך זה בדיוק יכול להיות.
נשים כאן breakpoint, נריץ עם דיבאגר, נגיע בדיוק לשורה הזאת ונתחיל להיכנס עם step into ה-F11 לתוך הפונקציה. אנחנו רואים שהאזור שמשתמש במחלקה, אותו מתכנת ב' אין לו גישה ישירה לdata member price, מפני שdata member price יכול להכיל מידע שגוי ולכן חסמנו אותו.
אפשרנו לו לגשת אליו על ידי שתי פונקציות, נתחיל עם set price והוא מנסה לשלוח מידע שגוי, מינוס 10. מינוס 10 נכנס לכאן לדה פרייס התנאי הופך להיות פולס מפני שמינוס 10 לא יותר גדול או שווה לאפס ולכן אין הכנסה בפועל של המידע לתוך הדאטה ממבר פרייס שממשיך להישאר אפס וכך
בעצם המחלקה הצליחה להגן על המידע שלה ולא הסכימה להכניס מבחוץ מידע לא חוקי. בואו נמשיך כאשר אנחנו מגיעים לאזור קוד שמשתמש במחלקה בשביל לקרוא את הפרייס אז בעצם הוא קורא לפונקציה getPrice ש-getPrice אין לה בעיה, היא אומרת אתה רוצה לראות את המידע בבקשה אני אחזיר לך את המידע, קח אותו.
המידע כמובן עדיין שווה 0 מפני שלא לכלכנו אותו בקוד או בערך לא נכון. כאן אנחנו מקבלים את המידע, לאחר מכן אנחנו מדפיסים וזאת הסיבה שראינו שיש לנו כרגע 0. בואו נמשיך להריץ והתוכנית בעצם הסתיימה.
אז אם אנחנו עכשיו מכניסים מידע חוקי, לדוגמה 10, כמובן שהמידע יעבור בהצלחה את הליי, ו-10 החל להיכנס ל-data member של האובייקט. בואו נסתכל על זה, נריץ את התוכנית ונראה שאם מי שמשתמש במחלקה לא טועה ומכניס לנו מידע שמבחינתנו הוא חוקי, אין לנו שום בעיה לקבל אותו ולכן הצלחנו להכניס
את המידע הזה לאובייקט. אבל מה בדיוק הבעיה עם השיטה הזאת? הרי היא עובדת פרפקט, אנחנו ראינו שהצלחנו להגן על הדאטה ממבר. המתכנת השני, מתכנת ב' שמשתמש במחלקה שלנו, לא יכול להגיע לדאטה ממבר האסור בצורה ישירה, מפני שהוא פרייבט, וחייב לעבור דרך שתי פונקציות,
סטר וגטר. אז למעשה הבעיה היא שהשימוש בפונקציה הוא טיפה יותר מורכב משימוש במשתנה. מה שבעצם קרה כאן זה שאם אני משתמש במשתנה רגיל public אז השימוש בו הוא מאוד מאוד פשוט כל מה שאני עושה אני פשוט כותב את שם האובייקט נקודה השם המשתנה כעת אני יכול להכניס לתוכו ערך או אם אני רוצה
אני יכול להדפיס אותו בדוגמא first product נקודה product name ופשוט אני קורא ממנו את הערך אבל כאשר אני משתמש בפונקציה השימוש בה מבחינת הקוד הוא טיפה ליותר מורכב זה אומר שאני צריך לקרוא לפונקציה אני צריך לפתוח פוגריים, אני צריך לשלוח את הערך.
כאשר אני רוצה לקרוא את המשתנה, בכלל אני צריך לקרוא לפונקציה שקוראת לי את המשתנה. וזה קצת יותר מורכב מהבחינה הזאת של שימוש בקוד. כאילו, כל מה שרצינו זה לגשת לאיזשהו data member, ובמקום פשוט לגשת אליו, היינו צריכים להשתמש עם שתי פונקציות שחושפות אותו החוצה.
אז בשפות יותר מתקדמות, כמו C-Sharp או VB.NET המציאו מנגנון שבא לפתור את הבעיה הזאת והמנגנון עצמו נקרא פרופרטי ולמעשה פרופרטי זה שתי פונקציות סטר וגטר שניתן להשתמש איתן כאילו שאנחנו משתמשים ממשתנה רגיל איך מבצעים את זה דבר ראשון
בואו נשים בהערה את שתי הפונקציות סט פרייס וגט פרייס ובואו נבנה במקומן את הproperty לפרופרטי יש הרשיית גישה שהיא כמובן במקרה שלנו public לפרופרטי יש טיפוס שהטיפוס נתונים שלו הוא אותו טיפוס של המשתנה אותו הוא חושף במקרה שלנו decimal לפרופרטי יש שם והשם הזה זה השם שנחשף
החוצה כמשתנה למרות שהproperty זה שתי פונקציות סתר וגתר עדיין אנחנו הולכים להשתמש איתו כאילו שהוא משתנה לכן אנחנו ממציאים שם של משתנה וזאת הסיבה שגם שיניתי את השם לפרייס עם פי קטנה בשביל שהשם של הפרופרטי שחייב להיות שם אחר משם המשתנה יהיה פרייס עם פי גדולה.
לאחר מכן אנחנו פותחים בלוק ושימו לב שזאת לא פונקציה ולכן אנחנו לא פותחים סוגריים וסוגרים סוגריים אלא פשוט פותחים בלוק. בתוך הפרופרטי יש שני חלקים וזה בדיוק הסטר והגטר שמקודם בנינו.
נתחיל עם הסט. כל מה שאנחנו צריכים לעשות זה פשוט לכתוב את המילה השמורה set ולפתוח פה בלוק. הבלוק הזה מקביל לכל הפונקציה הזאת. מה בדיוק פונקציית הסתר עשתה?
פונקציית הסתר קיבלה מבחוץ איזשהו ערך, בדקה אותו, ורק אם הוא היה חוקי שמה אותו בתוך הdata member. אנחנו צריכים לבצע אותו הדבר.
אבל רגע, פונקציית הסתר קיבלה משתנה שקראנו לו deprice. אין לי כאן משתנה שנקרא deprice, אבל יש לי מילה שמורה שנקראת value.
value זאת מילה שמורה שניתנת לשימוש בתוך הסתר של הפרופרטי והיא מכילה את אותו ערך שמישהו מנסה לשלוח מבחוץ. איך אנחנו עכשיו משתמשים עם זה?
כל מה שאנחנו צריכים לעשות זה לבצע בדיקה. האם אותו value שמישהו מנסה להכניס לפרופרטי שלנו הוא חוקי, כלומר גדול או שווה לאפס? אם כן, בואו ניגש למשתנה Price שהוא ה-Data Member ונכניס לתוכו את אותו ה-Value.
זה קוד שהוא מאוד דומה לקוד שיש כאן. גם כאן קיבלנו איזשהו ערך מבחוץ, עשינו עליו בדיקה אם הוא היה חוקי והכנסנו אותו לתוך המשתנה. באזור של הגטר אנחנו פשוט משתמשים עם הפונקציה גט וכל מה שאנחנו צריכים לעשות בתוכה זה Return Price שזה בעצם קוד זהה לקוד של פונקציית הגטר שמקודם עשינו ומה שבנינו פה זה הproperty ויש הבדל גדול
בין הproperty שבעברית זה מאפיין לבין data member שהוא משתנה או שדה field data member זה משתנה אמיתי שנפתח בזיכרון ושומר מקום עבור ערך מסוים במקרה הזה עבור price פרופרטי זה לא משתנה, זה שתי פונקציות שהתפקיד שלהן זה לחשוף את המשתנה, כי המשתנה עצמו הוא פרייבט מפני שיכול להיות בו מידע שגוי, ולכן אם מבחוץ מתכנת ב' רוצה להגיע אליו,
הוא חייב להגיע אליו דרך אותו פרופרטי. הפרופרטי מאפשר גם להכניס לתוכו ערך דרך ה-set, וגם לקרוא ממנו ערך דרך ה-get. אבל הפרופרטי הוא שם אחד, פרייס, ולא שני שמות כמו הפונקציות סטר וגטר.
אז איך אנחנו עכשיו משתמשים עם הפרופרטי? כל מה שאנחנו צריכים לעשות, בואו נשים את זה בהערה, נגדיל פה את התוכנית, נשים את זה בהערה. כל מה שאנחנו צריכים לעשות זה פשוט לפנות לאובייקט, נקודה, ועכשיו אנחנו רואים את ההבדל בין Data Member לבין פרופרטי מבחינת האייקון.
Data Member זה מעין קופסה כזאת, זה בעצם הגיוני מפני שאפשר להגיד שDataMember זה כמו משתנה או מקום בזיכרון או איזושהי כוסה.
Property זה מעין סימן עם יד כזאת, אייקון אחר, אבל מאחוריו בדרך כלל יישב DataMember. אם אנחנו רוצים להכניס לתוכו ערך, כל מה שאנחנו צריכים לעשות זה שווה.
אם אנחנו רוצים לקרוא ממנו ערך, כל מה שאנחנו צריכים לעשות זה פשוט לפנות אליו כאילו שהוא DataMember. עכשיו, אם אנחנו נריץ את זה אנחנו נראה שאנחנו לא אמורים לראות את המינוס 10 אלא אמורים לראות 0. בואו נריץ, נקבל 0 ונבין למה בעצם קיבלנו 0 על ידי הרצה עם דיבאגר.
נשים פה breakpoint, נריץ את התוכנית, נגיע בדיוק להכנסה של הערך וננסה ללחוץ על F11. בואו נראה אם התוכנית תאשר לנו להיכנס עם F11 לתוך הפרופרטי ואם כן לאן בדיוק אנחנו אמורים להיכנס.
בואו נלחץ על F11 ונראה שלא הצלחנו להיכנס לתוך הקוד של הפרופרטי בעזרת הדיבאגר התוכנית כן התבצעה אבל לא נכנסנו בעזרת הדיבאגר לתוך הפרופרטי מפני שבי דיפולט ויז'ל סטודיו לא מאשרת לדיבאגר להיכנס לקודים של פרופרטיז כנ"ל כאן אם אנחנו ניכנס עם F11 עוד פעם אנחנו נראה שהתוכנית כביכול ממשיכה לרוץ,
התבצעה אבל הדיבאגר לא נכנס פנימה ואנחנו יכולים לשנות את ההתנהגות הזאת בוויז'ל סטודיו. איך אנחנו עושים את זה?
כל מה שאנחנו צריכים לעשות זה ללכת ל-Tools לגשת ל-Options כאן לפנות לאזור של ה-Debugging בצד שמאל ובאזור של ה-Debugging יש לנו פה V על step-over-properties שב-default ה-v הזה מסומן.
זה אומר בוא תדלג מעל properties בדיבאגינג ואנחנו לא רוצים לדלג עליו כרגע אז אנחנו צריכים להוריד את ה-v הזה.
נבצע אוקיי, נשמור ונריץ עוד פעם את התוכנית. נגיע בדיוק לנקודה הזאת עם הברקפוינט ועוד פעם נלחץ עלף 11. ושימו לב מה קורה הפעם הדיבאגר הצליח להיכנס לתוך הפרופרטי ישירות לבלוק של הסט.
למה אנחנו נכנסנו לסט? למה בעצם הסט מופעל? והסיבה היא כי אנחנו מנסים להכניס ערך לתוך הפרופרטי ולא לקרוא ערך מתוך הפרופרטי. כאשר אתם מנסים להכניס ערך לפרופרטי אוטומטית .NET תפעיל לכם את הסט.
כאשר אתם מנסים לקרוא ערך מהפרופרטי אוטומטית .NET תפעיל לכם את החלק של הגט ותחזיר לכם את הערך. אז כעת בגלל שאנחנו מנסים להכניס מינוס 10 הסט מופעל בואו נמשיך לרוץ.
נראה שערך ה-value הוא המינוס 10 שמנסים להכניס. מינוס 10 לא גדול או שווה ל-0 ולכן ה-if לא מתקיים ולא הכנסנו ערך שגוי לתוך ה-price שממשיך להיות 0.
בואו נמשיך, נגיע לאזור שקורא ערך מה-property כי אנחנו בעצם מדפיסים אותו אז אנחנו בעצם אפשר להגיד שאנחנו קוראים את הערך שלו. ניכנס עם F11 וניחשתם נכון הגענו לאזור של הגט.
הגט כל מה שהוא עושה הוא מחזיר לנו את הערך כעת אנחנו יכולים לראות אשר קראו 0. לא, הצלחנו להכניס ערך שגוי לתוך האובייקט. אם אנחנו נמשיך ונדפיס את הערכים על המסך אנחנו יכולים לראות שעדיין יש לו 0.
אז בעצם השתמשנו כעת בפרופרטי.