פרויקט מעשי ב-#C - תוכנת צייר - חלק 30
פרקי ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 30
תמלול ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 30
הטקסט המלא של הדקות הראשונות בהרצאה «פרויקט מעשי ב-#C - תוכנת צייר - חלק 30» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
טוב. בהרצאה האחרונה על Whiteboard, אה, בנינו את ה-Whiteboard הזה ואנחנו, אה, בשלבים של לנקות ולסדר את הקוד ולהפוך אותו, אה, לקוד יציב.
מעבר לכך שהמערכת מתפקדת בצורה יציבה, אנחנו רוצים גם שהקוד עצמו יהיה יציב. זאת אומרת, שאם אנחנו, אה, עוזבים את המערכת ונותנים לתכנת אחר לעבוד על המערכת הזו, אז זה יקשה עליו.
אנחנו רוצים להקשות על התכנת ל-לעשות נזקים. אז בזה שאנחנו מסדרים את הקוד ועובדים לפי חוקים, אנחנו בעצם, אה, מייצבים את המערכת לאורך זמן.
בואו נסתכל על הקוד. נראה מה עוד אפשר לסדר. אז, אמ, אם אנחנו מסתכלים על line, לדוגמה, הדבר הראשון שאני רואה זה ש-p אחד ו-p שתיים בעצם לא אמורות להיות נגישות מחוץ, מחוץ לקלאס הזה.
line, כן? אחד מהרעיונות של אינקפסולציה, שלהפוך קלאס לקפסולה, לרכיב סגור, ל... כדורית סגורה או מסתוגרת, זה שכמה שיותר דברים לא נגישים מחוץ לקלאס.
לדוגמה, p אחד ו-p שתיים, אין סיבה בעצם שהם יהיו internal. מה זה internal? internal ו-public בעצם מבחינתנו כרגע זה אותו דבר.
internal ו-public, שניהם אומרים שכל מקום אחר בקוד שלנו, כל קלאס אחר יכול לגשת לשדה הזה. ולהזיק. אז אם נסתכל על התוכנית עצמה...
וננסה באמת להזיק, נגיד panel whiteboard. ניקח את, את אירוע, אה, mouse up לדוגמה. אז יש לי פה את line והרי אני יכול עכשיו בטעות, לא במזיד.
בוא נעצור את הריצה. אני, התכנת, בלי כוונה יכול לבוא ולהגיד אין לי נקודה p אחד שווה ל-new point. נכון? כי p אחד הוא מסוג point.
יפה. ולהגיד, "אז סתם, בא לי שזה יהיה אפס, אפס בטעות. לא יודע. לא, לא, לא חשבתי יותר מדי." ואני מריץ.
אה, אז הזזנו ל-line, אז נצייר איזשהו line ודברים נורא מוזרים. ה-התקלקל. התקלקלה הלמה? התקלקל-- יש באג.
זה בעצם באג. יש לנו איזשהו באג. עכשיו, לכו תמצאו את הבאג. מה גרם לזה? מה גרם לבאג הזה?
אחד מעקרונות ה-debugging החשובים ביותר זה עיקרון הלוקליזציה. זה אומר אם יש לנו באג, אנחנו רוצים מהר ככל שאפשר לבצע תהליך של לוקליזציה, לקב-- לדעת איפה בעצם יכול היה להיווצר הבאג.
והרעיון של אינקפסולציה ויותר, יותר מזה, המונח private, הם מסייעים בידינו ל-להגיע ללוקליזציה גבוהה. לדוגמה, אם line, אם זה היה private, אז p אחד לא היה נגיש מחוץ ל-line.
אם נחזור לתוכנית עצמה, p אחד היה נגיש. p אחד נגיש למישהו מחוץ ל-line. ובלי שום הצדקה. אין סיבה שמישהו מחוץ ל-line ירצה לעדכן את p אחד, כי, כי הוא עומד לעשות נזק ואין שום יתרון לנובע מזה.
איזה יתרון יש בזה שאני מחצין את p אחד? אין שום יתרון. אז אולי לא נאפשר את זה. אם לא נאפשר את זה, אז נקבל אפקט לוקליזציה. זאת אומרת, אם יש באג ב-line, אז בוודאות של מאה אחוז הוא נוצר בקובץ הזה.
יש פה קובץ של שלושים ותשע שורות. לעומת מערכת של אני מניח, אה, סדר גודל של פי עשר או פי, פי חמישים מהשלושים ותשע שורות האלה.
אז איך יותר קל לדבג? שבאג יכול למרוח מכל מקום או שבאג יכול למרוח רק ממקום מאוד מצומצם? זה הגיוני. אם יש לי באג ואני יודע שבוודאו-- אני ואני רוצה לנחש איפה הוא, אז אם יש לי באג בline אני רוצה להיות בוודאות גבוהה שהבאג נוצר בקובץ הזה.
בקיצור, אנחנו נשנה את הinternal הזה לprivate. באותה הזדמנות גם את internal הזה נשנה לprivate וננסה להריץ. כמובן שיש לנו באג.
מה הבאג? line P אחד is inaccessible. דאבל קליק. כן, בשורה הזו whiteboard line P אחד is inaccessible due to its protection level.
מצוין. אין איזושהי מזעקה. נעיף את השורה הזו. ונריץ שוב. הכול נראה שעובד ואין את הבאג.
יפה. אז בלי להפסיד שום דבר הרווחנו. לא הרווחנו ביצועים בזמן אמת, לא הרווחנו ביצועים גרפיים. הרווחנו ביצועים באורך החיים של המערכת שאנחנו בונים.
קשה יותר עכשיו לתכנת לעשות נזקים. התכנית לא יכולה עכשיו סתם להזיק לL, בטעות. אז למדנו על עיקרון האנקפסולציה והלוקליזציה והשתמשנו בprivate.
עכשיו, הקלאס עצמו חייב כמובן להישאר internal כי אני רוצה להיות מסוגל לעשות new. כנראה בmouse down. אני רוצה לעשות new line.
אני רוצה להפעיל את הקונסטרקטור מחוץ לקלאס, אז הקונסטרקטור חייב להיות זמין לי. בוא נחזור לline. אז הקלאס, כמובן שהקלאס עצמו צריך להיות זמין לי כי אני רוצה להיות מסוגל להכיר את line בין אם זה בין אם את הקונסטרקטור או בין אם את התכנים של הקלאס אני.
בוא נגיד שדוגמה יותר טובה להכיר את הקלאס זה דווקא בשורה הזו. אני רוצה להכיר את הקלאס, אז אני חייב שהוא יהיה זמין לי. לכן line חייב להיות internal.
internal זה אומר שכל הפרויקט מכיר. בהמשך אנחנו גם נלמד על public. public הוא אפילו יותר מתירני. public אומר שאם יש לנו גם עוד פרויקטים אחרים, כרגע אין לנו דוגמה לזה, אבל בשלב מתקדם של הלימודים שלכם אנחנו נלמד על, על, על כמה פרויקטים שמשתפים פעולה, מה שנקרא exe וdll אז שם public אומר שאפילו מdll אחד לשני, מexe לdll יש היתר גישה.
internal אומר שרק בתוך אותו פרויקט אני בעצם יכול לקבל גישה. אז כרגע אני רוצה להרשות לכל הפרויקט להכיר את line למרות שבעצם אני רוצה שרק form אחד יכיר את line.
אבל אין ברירה ועד כדי כך לא ניתן. אני לא יכול להגדיר בעזרת המילים השמורות, זה נקרא access level. אני לא יכול להגדיר בעזרת רמת הגישה.
בעזרת הaccess level אני לא יכול להגיד שרק למישהו מותר ולמישהו אחר אסור. אני אומר שאו לכל הפרויקט מותר או ל-- או לכל המערכת מותר. בעזרת dot net security ניתן להגיד שרק לקלאס מסוים מותר לגשת, אבל זה נושא מתקדם שעוד נגיע אליו.
טוב, אז שינינו את P אחד וP שתיים להיות private. מה עוד אפשר להפוך ליותר מוגן? אז כמובן את הnamespace עצמו לא ניתן, לא ניתן להגדיר אם הוא internal עד כמה שאני יודע או משהו כזה.
הקלאס עצמו אמרנו חייב להיות internal כי אני רוצה לבצע casting. הקונסטרקטור חייב להיות internal כי אני רוצה ליצור אותו גם כן מבחוץ. P אחד וP שתיים ראינו שלא צריכות להיות מוכרות מבחוץ לline.
draw אני חייב שהיא תהיה מוכרת. האמת שאני יכול גם לעשות עכבר ימני ולהגיד לו Find all references. ואני רואה את ה, את המקומות שמשתמשים בdraw. אני רואה את המימושים, אלה אני מיד רואה שאלה המימושים של draw ואני רואה שזה שימוש של F נקודה draw.
אז מכיוון שdraw חייבת להיות זמינה מבחוץ אז היא חייבת להיות internal. אז לכן גם draw שלנו שאנחנו דורסים את הdraw של shape חייבת גם היא להיות internal. update אם נעשה עליו Find all references.
ונלך לשימוש, זה השימוש. אז נראה שיש שימוש מבחוץ. שוב חייב להיות internal. מה לגבי update הזה? אני רואה שימוש כנראה פנימי.
אני רואה גם כאן שfree-- זה של freehand ואנחנו לא עוד ענין כרגע בfreehand. אבל מה זה? אז זה, אה, שימוש בupdate שוב מבחוץ.
אז וכנראה שגם את זה צריך ל חייב להיות internal. יפה, אבל נזהרנו. עברנו על כל על כל הקוד של הclass line ונזהרנו את הנזקים בזה שנזהרנו את אפשרויות הגישה מבחוץ.
זה נקרא least access. כמה שפחות לאפשר גישה. טוב, בואו נעבור עכשיו לclass shape. נראה מה פה אפשר לעשות. אז לclass shape יש את width רוחב ונראה שהוא זמין מבחוץ.
בואו נסתכל עד כמה באמת הוא זמין. Find all references. זו הגדרה. אוקיי, מה זה? זה במקרה אותו שם של משתנה.
זה יותר נראה כמו באג של הויז'ואל סטודיו. אה, אנחנו בתוך class line. סליחה, טעות שלי. אנחנו מייצרים פה pen. לא, צודק.
אנחנו רוצים מclass line לגשת לwidth כדי לייצר עט. אבל האמת היא שכשאני חושב על זה, בעצם אני צריך לייצר עט גם ב גם בfreehand. אז, אה, אז אם אני רוצה לעשות דבר דומה גם בline וגם בfreehand ששניהם יורשים מshape, אז אולי נעשה את זה פעם אחת בshape.
אולי נייצר את הpen זה בבסיס ולא כאן, אבל עוד נחזור לזה. אבל כרגע אני רק רואה שלwidth אני ניגש מתוך line.
השאלה היא האם אני ניגש לwidth מחוץ להיררכיית הירושה של shape. למה? כי יש לי רמת הגנה שנקראת protected וprotected אומר שרק בתוך היררכיית הירושה מותר לי לגשת לשדה מסוים.
אז אם אני רוצה לגשת לwidth מתוך איזשהו קוד בתוך line שיורש מshape, אבל אני לא צריך לגשת לwidth מחוץ לline וגם לא מחוץ לfreehand ולא מחוץ לshape. בקיצור, אם אני לא רוצה לגשת לwidth מחוץ להיררכיית הירושה של shape, אז בעצם width יכול להיות protected.
בואו נבדוק שזה באמת נכון. אני מסתכל פה על כל הקבצים ואני רואה שבעצם אני באמת לא ניגש לwidth ממקום אחד. תמיד אני ניגש, הוא מוגדר בshape.
אני ניגש לwidth מline, מshape, מline, מfreehand, מfreehand. תמיד אני ניגש לwidth מתוך היררכיית הירושה, מתוך היורשים. אז בואו נלך רגע לwidth.
Go to definition. ונשנה אותו. האמת היא שאני רואה שהוא read only. ברגע שאני רואה שמשהו read only, אז אפשר להגיד בעצם מה זה אכפת לי אם הוא יהיה internal או public או לא משנה מה.
כי ממילא לא ניתן לשנות אותו אחרי היצירה. אז זה באמת שיקול נכון, אז אפשר לתת להפוך אותו לpublic. הבעיה שאם נחליט מחר לשנות אותו שהוא לא יהיה read only אז הוא יישאר internal.
נגיד נחליט שניתן לשנות את העובי ובהמשך אנחנו בהחלט נאפשר לשנות עובי וגם צבע. אז הוא לא יהיה read only. אם הוא לא יהיה read only אז נישאר עם internal.
אז אולי כבר עכשיו כדי להגן עלינו מחר נשנה את זה למשהו יותר מוגן. בכל מקרה, תמיד כדאי כשבונים מערכת לעשות הכל private והכל read only.
כמה שיותר דברים שיהיו private וread only ככה המערכת שלכם תהיה יותר יציבה בטווח הארוך. או כמו שאומר הפתגם לו כל העולם היה private read only אז בהחלט העולם היה מקום טוב יותר.
אז בואו נשנה את width לprivate. אז זהו. אם אני משנה אותו לprivate בואו נעשה עוד הריצה.