PracticU

בניית פקד חדש - User Control

בלי כתוביותעם כתוביות
PracticU › קורס WinForms - תוכנות רגילות בווינדוס › בניית פקד חדש - User Control
מילון מושגים:
רכיב - יחידת בניין עצמאית וניתנת לשימוש חוזר בתוך מערכת או ממשק משתמש, שאחראית על חלק מוגדר מהתפקוד.
ממשק - נקודת מגע בין רכיבים: ממשק משתמש שבו אדם מפעיל תוכנה, או ממשק תכנותי שמגדיר אילו פעולות רכיב אחד חושף לאחר.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
טופס - אזור בממשק שבו המשתמש מזין נתונים בשדות ושולח אותם, למשל טופס הרשמה או התחברות.
גופן - העיצוב הגרפי של האותיות והתווים המוצגים בטקסט, הכולל צורה, סגנון וגודל.
DLL - קובץ ספרייה ב-Windows המכיל קוד ופונקציות שתוכנות שונות יכולות לטעון ולהשתמש בהן במשותף.

בניית פקד חדש - User Control
השיעור עוסק בבניית רכיב ממשק משתמש חדש (User Control). הסיבה: לפעמים אין ברשימת הרכיבים את מה שנדרש, או שרוצים התנהגות חוזרת של רכיב קיים שנשמרת לכל מקום שבו משתמשים בו.
הדוגמה: תיבת טקסט שמשנה צבע
בכל הקשה בתיבה הצבע של הטקסט מתחלף לצבע אקראי. אפשר לכתוב את הקוד באירוע TextChanged, אבל אז צריך לחזור על הקוד בכל תיבה. במקום זה בונים רכיב חדש.
יצירת User Control
1. בפרויקט מוסיפים פריט חדש מסוג UserControl, ונותנים שם משמעותי (למשל HappyTextBox).
2. מעצבים את הרכיב: מגדירים את הגודל, ומוסיפים בתוכו תיבת טקסט בגודל זהה, עם מיקום (0,0).
3. מזיזים את הרכיב הפנימי עם Dock = Fill, כדי שיתפוס את כל שטח הרכיב כשמשנים את גודלו.
4. בקוד של הרכיב כותבים את הלוגיקה: באירוע TextChanged של התיבה הפנימית מגרילים צבע (שלושה ערכים בין 0 ל-255 עם Random) ומגדירים אותו ל-ForeColor.
5. בונים את הפרויקט. הרכיב מופיע בטולבוקס, ואפשר לגרור אותו לכל טופס. כל גרירה יוצרת מופע חדש שמתנהג באותו אופן.
חשיפת מאפיינים ואירועים
- הרכיב הפנימי מוסתר מהמשתמש של הרכיב. כדי לאפשר שינוי מבחוץ, יוצרים מאפיינים ציבוריים (public) שמעבירים את הערך לרכיב הפנימי: MultiLine, Font, BackColor, Text.
- כדי לשלוח אירוע החוצה, מגדירים אירוע ציבורי מסוג EventHandler ומפעילים אותו מתוך אירוע הרכיב הפנימי.
- הדובר ציין התנגשות בשם אירוע שכבר קיים ברכיב הפנימי (TextChanged), ולכן בחר שם אחר (InnerTextChanged).
עיצוב וגודל
אחרי שינוי בקוד של הרכיב, צריך לשמור ולבנות את הפרויקט (Build) כדי שהמעצב יכיר את השינוי. לעיתים צריך למחוק את הרכיב מהטופס ולגרור אותו שוב.
שימוש חוזר
אם רוצים להשתמש ברכיב גם בפרויקטים אחרים, בונים אותו כ-DLL, ומוסיפים אותו לטולבוקס דרך Choose Items.
תרגיל
יוזר קונטרול שמציג שעון: לייבל אחת בתוך הרכיב, שחושפת את צבע הרקע, צבע הגופן, הפונט והטקסט. בכל דקה עגולה (שניות = 0) הרכיב מעלה אירוע שמדווח את השעה, והטופס מציג את השעה שדווחה.
בסיום השיעור הסטודנט יודע לבנות רכיב משלו מרכיבים קיימים, לחשוף מאפיינים ואירועים, ולהשתמש ברכיב בטפסים שונים בלי לחזור על הקוד.
השיעור הבא בקורס: שימוש במספר טפסים - Multiple Forms

פרקי ההרצאה: בניית פקד חדש - User Control

  1. 00:00

    מדוע בונים פקד חדש

  2. 01:23

    אירוע TextChanged וצבע רנדומלי

  3. 03:10

    בעיית שכפול הקוד

  4. 04:24

    יצירת UserControl

  5. 05:01

    עיצוב משטח הפקד

  6. 07:22

    העברת הלוגיקה לפקד

תמלול ההרצאה: בניית פקד חדש - User Control

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

  1. 00:02

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

  2. 00:16

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

  3. 00:30

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

  4. 00:45

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

  5. 01:11

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

  6. 01:23

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

  7. 01:35

    ומה שאנחנו רוצים לעשות באירוע טקסט צ'יינג' זה לייצר צבע רנדומלי, בואו ניקח פה משתנה random rnd שווה new random, אחרי שאפילו נכנסים אותו פה פעם אחת, אחרי שלקחנו צבע רנדומלי אנחנו רוצים, או משתנה רנדומלי, אנחנו רוצים לייצר שלושה גוונים red, green ו-blue, red rnd next של 0 עד 256, כי אם אני רוצה לייצר איזשהו צבע רנדומלי

  8. 02:13

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

  9. 02:41

    אם יש לי צבע רנדומלי, אני יכול לבוא לטקסט בוקס ולהכניס לתוך ה-4Color את הצבע הרנדומלי שמצאתי. בואו נריץ, נראה קודם כל שזה עובד.

  10. 02:56

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

  11. 03:11

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

  12. 03:28

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

  13. 03:39

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

  14. 03:52

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

  15. 04:08

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

  16. 04:24

    איך אנחנו עושים את זה? כל מה שאנחנו צריכים לעשות זה לגשת לפרויקט שלנו, מקש ימני Add New Item, או אני יכול אפילו לראות את זה כאן, גם אם הייתי הולך לניו אייטם וגם עם יוזר קונטרול אני רואה שבעצם יש לי פה אפשרות לבחור יוזר קונטרול נותן לו שם משמעותי לדוגמה happy text box מתאר תיבת טקסט שמחה כזאת נבצע

  17. 05:03

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

  18. 05:25

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

  19. 05:36

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

  20. 05:48

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

  21. 06:01

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

  22. 06:37

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

  23. 07:00

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

  24. 07:20

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

  25. 07:34

    דרך אגב, אני רואה שלא נתתי שם לתיבה וזה לא אוקיי לתיבת הטקסט. בואו נלך וניתן ל-TXT data, לא משנה לי איזה data זה.

  26. 07:48

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

  27. 08:05

    נעתיק את הקוד שהיה לנו מקודם. ראשית יש לנו את ה-RND. נשים אותו פה, נחזור לטופס, נעתיק את כל הקוד הזה, נשים אותו פה, נשנה את זה ל-txt data, ניפטר ממרחבי שמות שאנחנו לא משתמשים איתם, ומה שאנחנו רואים כרגע זאת הקלאף של ה-user control שקראנו לה happy text box, היא יורשת מהמחלקה user control וזה הדברים

  28. 08:57

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

  29. 09:10

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

  30. 09:32

    בואו נפתח פה את הטופס. איפה התיבת טקסט נמצאת? אז כל מה שאנחנו צריכים לעשות זה ctrl+shift+b ולבנות את התוכנית שאנחנו כותבים כרגע.

  31. 09:46

    בואו נעשה ctrl+shift+b, פתאום אנחנו רואים שיש לנו כאן Happy Text Box User Control Components. בואו נגרור אותה ונראה תיבת טקסט תמימה לחלוטין, פשוטה לגמרי.

  32. 10:03

    אנחנו יכולים לגרור ולראות שאנחנו יכולים לשים כמה כאלה. נשמור, בואו נריץ. אני מריץ את האפליקציה ואני רוצה להתחיל לכתוב בתוך אחת מהן.

  33. 10:22

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

  34. 10:36

    אחלה. בואו נראה עוד כמה דברים. קודם כל, מה השמות שלהם? אז אני רואה שהראשון שגררתי, אוטומטית המערכת נותנת לו את השם Happy Text Box 1, השני Happy Text Box 2, השלישי Happy Text Box 3, כלומר, Visual Studio אוטומטית

  35. 10:54

    לוקחת את השם של היוזר קונטרול ומוסיפה מספר לידו. אנחנו יכולים כמובן לגשת ולתת שם אחר, לדוגמה, txt first name וזה יהיה txt last name.

  36. 11:10

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

  37. 11:33

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

  38. 12:00

    אם עשינו איזשהו שינוי ב-user control, כדאי מאוד לבצע סייבינג ואז ctrl+shift+b לצורך בנייה של כל האפליקציה ואז לחזור בחזרה לטופס ולפעמים אנחנו גם צריכים ללכת ולמחוק את מה שעשינו מכדי שהשינויים ייתפסו.

  39. 12:25

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

  40. 12:43

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

  41. 13:01

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

  42. 13:34

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

  43. 13:59

    בואו נקרא לו מולטי ליין ונגדיר פה get set ונחשוף את הערך של המולטי ליין של תיבת הטקסט שבתוכו txtdata.multi line

לקורס המלא: קורס WinForms אונליין

ההרצאה הקודמת: יצירת גרפיקה - GDI

ההרצאה הבאה: שימוש במספר טפסים - Multiple Forms

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

  • User Controls
  • USER MODULE
  • Application Control - צ'ק פוינט - חלק 1
  • בניית מודל

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

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