PracticU

פרויקט מעשי ב-#C - תוכנת צייר - חלק 23

בלי כתוביותעם כתוביות
PracticU › פרויקט מעשי ב-#C - תוכנת צייר › פרויקט מעשי ב-#C - תוכנת צייר - חלק 23
מילון מושגים:
פונקציה - קטע קוד בעל שם שמבצע משימה מוגדרת, מקבל ערכי קלט (פרמטרים) ויכול להחזיר תוצאה. מאפשרת לארגן קוד ולהשתמש בו שוב.
מחלקה - תבנית בתכנות מונחה עצמים שמגדירה אילו נתונים ופעולות יהיו לאובייקטים שנוצרים ממנה.
טופס - אזור בממשק שבו המשתמש מזין נתונים בשדות ושולח אותם, למשל טופס הרשמה או התחברות.
אובייקט - יחידה בתכנות מונחה עצמים שמאגדת נתונים (תכונות) ופעולות (מתודות). נוצר בדרך כלל ממחלקה המשמשת כתבנית.
Visual Studio - סביבת פיתוח משולבת (IDE) של מיקרוסופט לכתיבה, ניפוי והרצה של קוד, בעיקר בשפות .NET.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
משתנה - שם שמפנה למקום בזיכרון שבו נשמר ערך שיכול להשתנות במהלך ריצת התוכנית, כמו מספר, טקסט או אובייקט.
באג - תקלה או שגיאה בקוד שגורמת לתוכנה להתנהג בניגוד למצופה.

פרויקט מעשי ב-#C - תוכנת צייר - חלק 23
בשיעור הזה ממשיכים לסדר את הקוד: הפונקציות שמציירות ומעדכנות את הקו מועברות לתוך המחלקות Line ו-Freehand, כך שהטופס מבקש מכל אובייקט לפעול ולא נכנס לפרטים הפנימיים שלו. התוצאה היא אותה התנהגות בקוד פשוט יותר.
השלבים העיקריים
1. הוספת Draw ל-Line: הוספת השלד של הפונקציה נעשית בעזרת Visual Studio, ואז מעבירים לתוכה את הקוד שמצייר את הקו. הנקודות הפנימיות נגישות ישירות בתוך המחלקה, ולכן אין צורך לכתוב אותן מחדש.
2. הפרדה בין שתי הנקודות: הפונקציה שמעדכנת נקודה ראשונה ב-MouseDown נפרדת מזו שמעדכנת נקודה שנייה ב-MouseMove. כל פונקציה מחשבת את הנקודה שלה בלי לחשוף את הרשימה.
3. עדכון מהטופס: הטופס מעביר לאובייקט את הערכים x ו-y שהגיעו מהאירוע, ואת ה-Graphics, והאובייקט מטפל בשאר.
4. ניקוי משתנים מיותרים: את ה-x וה-y הקודמים אין צורך לשמור, כי הנקודה האחרונה ברשימה כבר מכילה אותם.
5. Freehand: עובר אותו תהליך, כך שגם הוא מטפל בציור ובעדכון הנקודות שלו.
טעויות נפוצות
- ב-MouseDown השתמשו בפונקציית העדכון של נקודה שנייה, ולכן הקו תמיד התחיל מנקודה (0,0). יש צורך בפונקציה נפרדת לנקודה הראשונה.
- שימוש במשתנים גלובליים שכבר לא קיימים אחרי ההעברה גורם לשגיאות קומפילציה. יש לעדכן את כל הקוד הפונה אליהם.
שימו לב
המטרה היא הכמוסה (אנקפסולציה): כל מחלקה אחראית על הנתונים שלה ועל הפעולות עליהם. המשימה לשלב הבא היא להגן על השדות הפנימיים, כך שאי אפשר יהיה לגשת אליהם מבחוץ.
בסיום השיעור התלמיד יודע להעביר לוגיקת ציור ועדכון למחלקה, לפצל פעולות לפי אחריות, ולזהות באג שנובע מעדכון נקודה לא נכונה.
השיעור הבא בקורס: פרויקט מעשי ב-#C - תוכנת צייר - חלק 24

פרקי ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 23

  1. 00:00

    המשך ניקוי הקוד והפחתת המורכבות

  2. 01:15

    יצירת מתודת Draw למחלקת Line

  3. 02:38

    העברת קוד הציור מ-Paint אל Line

  4. 04:00

    עדכון הנקודות דרך מתודת Update

  5. 07:18

    העברת העדכון מ-Paint אל FreeHand

  6. 09:29

    שמירת הנקודה האחרונה במקום X ו-Y קודמים

  7. 12:13

    אינקפסולציה: הקפסולה מטפלת בעצמה

  8. 14:00

    מתודת Update שמקבלת x ו-y

תמלול ההרצאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 23

הטקסט המלא של הדקות הראשונות בהרצאה «פרויקט מעשי ב-#C - תוכנת צייר - חלק 23» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:04

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

  2. 00:27

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

  3. 00:56

    לא רוצים להתעסק עם הפנימיות המורכבת של הליין. זה מה עם כל האנדרוסקורים ו-P1 ו-P2 ו-X ו-Y. אני לא רוצה להתעסק עם זה כרגע.

  4. 01:08

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

  5. 01:31

    אנחנו נוסיף את הפונקציה על ידי האוטו קומפליטר, generate methods tab, tab זה המינימום של פונקציה. generate methods tab for draw in line אנחנו נותנים לline להוסיף את draw יפה היא נוספה עכשיו אנחנו ניקח את שתי השורות האלו לשם הגענו לפה זה ה-method tab נסיר את ה-throw שבעצם אמור לחרוג בזמן ריצה

  6. 02:13

    the method or operation is not implemented אם נריץ את זה ככה כמובן שנחטוף חריגה אם נגיד אם נצייר לין ואז ננסה לגרום לו לצייר את עצמו בעזרת מעבר שקף יפה זה מה שקורה אנחנו מגיעים לחריגה שמזכירה לנו שבעצם עוד לא סיימנו אז נעצור פה את התוכנית נמחק את השורה הזו ונוסיף את הקוד שלקחנו מתוך פיינט שוב פה אנחנו לא צריכים

  7. 02:53

    להגיד לו color אנחנו לא צריכים להגיד לו we אנחנו לא צריכים להגיד לו כי הוא מכיר את P1 הוא מכיר את P1 הוא מכיר את P2 הוא מכיר את P2 כי הן נמצאות פה לידו.

  8. 03:08

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

  9. 03:39

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

  10. 04:05

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

  11. 04:21

    נגיד לו תתעדכן וקבל כאן את נגיד לו בעצם את p2 זה לא יהיה הבדל משמעותי אבל זה יהיה כן זה גם יהיה הבדל יפה אז נגיד לו פה point או שנשאיר את זה בשבילו שהוא יטפל בזה אנחנו רק נעביר לו את e.x ו-e.y הוא יקבל את זה ואת כל השאר כבר יעשה בעצמו אפילו את create graphics הוא לא יוכל כי אין

  12. 05:02

    לו פה אינטר לפאנל אז נצטרך לתת לו גם את create graphics אז לפני כן ניקח מפה את השורה הזו נשים אותה כאן ונעביר גם את g כל הקוד הזה ניקח מכאן ואת Update, ניצור Generate Method, Update for Line, ונלך לשם, נמחק את ה-Throw, נוסיף את הקוד שלנו, נמחק את כל מה שקשור ל-L, האמת היא שקיבלנו פה, כן, הוא קרא לזה שמות מגוחכים, זה Int X וזה

  13. 05:57

    Int Y, ופשוט נקבל פה את X ואת Y, ביצירה של הפן נגיד לו Color, ובדרול ליין נגיד לו הכל בלי מה שמיותר. זו הייתה אפדייט.

  14. 06:26

    בואו נריט, זה לא כל כך עובד, מה הבעיה? E אינו מוכר, נגדיר פה את G ולזה נקרא G ונריט. עדיין יש בעיה, גרפיקס מיותר ונריט. נצייר ציור בפרי-הנד, נצייר ציור בליין, B נציג, נלך קדימה, נחזור אחורה, זה עובד מצוין.

  15. 07:03

    מה עוד אפשר לנקות? אנחנו כרגע בשלב שבו אנחנו בעצם מנקים קוד. אז יש לנו קלאס line, יש לנו קלאס freehand, בואו שוב נחזור לפאנל, נסתכל על pain, בוא נגיד שאנחנו מחפשים עוד איזה אינקפסולציה ניתן לבצע, עוד איזה קוד נמצא מחוץ לקלאס שאפשר להכניס אותו לתוך הקלאס.

  16. 07:33

    זה button line ופה אנחנו פשוט קוראים ל update יותר מזה אי אפשר כרגע לעשות שום דבר במוב מה יש לנו כאן אז יש לנו אותו דבר לגבי freehand בעצם אנחנו יכולים לפנות לfreehand ולהגיד לו תדכן בעצם קבל עוד נקודה כי זה בעצם המהות של כל הפונקציה הזו הוספת הנקודה לpoint של הfreehand שוב גם כאן את g אנחנו נשלח וגם את g נשלח ואת e.x ואת e.y.

  17. 08:20

    ניקח את הקוד הזה על הכתפיים ונוסיף את update לפרי-הנד ונלך לבקר אותה. זאתי update, נדביק את הקוד שלנו כאן, אני רואה ש... כן, זה בסדר.

  18. 08:44

    שמות המשתנים, זה אנחנו יודעים שקוראים לו e.y. וזה נקרא x. כאן אנחנו לא צריכים את פרי-הנד ולא צריכים את פרי-הנד ו-G draw line זה ה-X וה-Y הקודמים וזה קצת בעייתי.

  19. 09:14

    תכף נדבר על ה-X וה-Y הקודמים ועל העדכון של ה-X וה-Y הקודמים ועל יצירת נקודה חדשה מתוך ה-X וה-Y החדשים שקיבלנו והוספתם לפוינט אז האמת היא שהשמירה של x והy הקודמים אנחנו לא צריכים כי זה נמצא בפוינט זה הנקודה האחרונה של פוינט אז בכלל כל הx והy האלה שני אלו בכלל מיותרים אין טעם לשמור אותם אני יכול לחלט

  20. 09:54

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

  21. 10:24

    אז אולי, תכף נעשה פה סדר, אז נגדיר פה פוינט P, יש לנו כבר כמה דברים, אז זה יהיה, נקרא לזה, נחלט P1 ונגדיר כאן את P2, ו-P2 ניצור אותה מה-X וה-Y שקיבלנו, וכאן נשלח את פי שתיים וכאן נשלח את פי אחת אולי לזה נקרא פן כדי לא ליצור בלבול אז פי אחת שווה אוקיי אנחנו צריכים לחלץ את מסוג

  22. 11:14

    פוינט מתוך פוינט במקום האחרון קאונט פחות אחד זה המקום האחרון זו הכניסה האחרונה במערך אז חילטנו את שתי הנקודות ואז אנחנו קוראים ל-draw line ומעבירים לה את pen, את p1 ואת p2.

  23. 11:48

    לא צריך לעדכן איזשהו משתנה גלובלי כי אנחנו כבר ממילא מעדכנים משתנה גלובלי הלא הוא פוינט בשתי הנקודות החדשות שהתקבלו x וy. האמת אפילו לא צריך ליצור נקודה חדשה כי זו למעשה p2.

  24. 12:13

    שוב נחזור לאיפה שהיינו, היינו ב-mouse move. כל הקוד המורכב הזה שעכשיו התעסקנו איתו העברנו לתוך הפונקציה Update.

  25. 12:31

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

  26. 12:50

    אנחנו רק נעביר לו את מה שהוא צריך. הוא צריך את G ואת ה-E. את ה-EX ו-EY. בואו נוריד את זה. שגיאות, יפה.

  27. 13:02

    במאוס דאון אנחנו מעדכנים משתנים גלובליים שכבר לא קיימים. מה אנחנו עוד עושים? אנחנו עושים עוד דברים שכנראה תלויים ב-X ו-Y.

  28. 13:17

    ב-Free Hand, במאוס דאון, מה אמרנו כאן? נתנו ל-FH Width ו-Color, אוקיי? ואז הוספנו לו את הנקודה T בלי לצפות שהוא יצייר שום דבר, אוקיי?

  29. 13:45

    אבל עדיין זה די דומה ל-Update. אז נקרא אולי ל update, נראה מה היא מקבלת. היא רוצה את g, את int x ואת int y. אז זה לא בדיוק אותה update, אבל היא דומה. אנחנו רוצים update שפשוט מקבלת את x ואת y.

  30. 14:11

    אז נגדיר update שמקבל את x ו-y, ואת הפוינט הזו נסיר,

לקורס המלא: פרויקט מעשי ב‑#C אונליין

ההרצאה הקודמת: פרויקט מעשי ב-#C - תוכנת צייר - חלק 22

ההרצאה הבאה: פרויקט מעשי ב-#C - תוכנת צייר - חלק 24

הרצאות קשורות מקורסים אחרים

  • תרגיל 24 - תוכנת צ'אט - חלק 1
  • פרויקט מעשי ב-#C - ספר טלפונים - חלק 1
  • תרגיל מעשי Delegate Event
  • שדרוג צייר שלנו על canvas

קורסים נוספים במסלול

  • קורס WinForms - תוכנות רגילות בווינדוס
  • פרויקט מעשי ב-#C - בונים מחשבון פשוט
  • פרויקט מעשי ב-#C - ספר טלפונים
  • קורס ADO.NET - חיבור אתר למסד נתונים
  • קורס תכנות מתקדם - #Advanced .NET C
  • קורס WCF - תקשורת למתקדמים בדוט-נט