PracticU

העברת מידע מ-Controller ל-View

בלי כתוביותעם כתוביות
PracticU › קורס MVC › העברת מידע מ-Controller ל-View
מילון מושגים:
קונטרולר - רכיב שמתווך בין הממשק לבין הלוגיקה והנתונים, מקבל בקשות ומחליט כיצד לטפל בהן (למשל בדפוס MVC).
View - רכיב שאחראי על הצגת המידע למשתמש (התצוגה) בדפוס MVC. גם טבלה וירטואלית מבוססת שאילתה במסד נתונים.
שרת - מחשב או תוכנה שמספקים שירות למחשבים אחרים (לקוחות) ברשת, למשל אחסון קבצים, אתר אינטרנט או מסד נתונים, ומגיבים לבקשות שלהם.
לקוח - תוכנה או מחשב שפונים לשרת ומבקשים ממנו שירות או מידע, למשל דפדפן שמבקש דף אינטרנט.
מודל - רכיב שמייצג את הנתונים ואת הלוגיקה העסקית באפליקציה. גם ייצוג מופשט של מערכת או תהליך.
Dictionary - מבנה נתונים שמאחסן זוגות של מפתח וערך, ומאפשר שליפה מהירה של ערך לפי מפתחו.
קומפיילר - תוכנה שממירה קוד מקור שנכתב בשפת תכנות לקוד שהמחשב יכול להריץ, ומדווחת על שגיאות תחביר.
בקשה - פנייה שלקוח שולח לשרת כדי לקבל מידע או לבצע פעולה. השרת מחזיר עליה תגובה.

העברת מידע מ-Controller ל-View
בצד השרת העבודה תמיד עוברת בין הקונטרולר לבין ה-View. הלקוח מגיע לקונטרולר, והקונטרולר צריך להעביר מידע ל-View שיציג אותו. בשיעור הזה נראה ארבע דרכים להעביר מידע, וכל אחת מתאימה למצב אחר.
המודל הראשי
המודל הוא המידע המרכזי שהלקוח רוצה לראות. הקונטרולר שולח אותו ל-View דרך View(model), ובתחילת ה-View מגדירים את טיפוס המודל בעזרת @model. למשל, מוצר עם מזהה, שם ומחיר נשלח, וה-View מציג את השם בעזרת Model.ProductName.
ViewData ו-ViewBag
למידע נלווה, שאינו המודל הראשי, אפשר להשתמש ב-ViewData. זה מילון (Dictionary) של מפתח וערך, ומפתח חייב להיות ייחודי. ב-View מגשים אליו באמצעות סוגריים מרובעים ועם המפתח. ViewBag הוא שיטה חדשה יותר ונוחה יותר: מאפיינים דינמיים, בלי מילון. הקומפיילר לא בודק את שמות המאפיינים, ושגיאה תתגלה רק בזמן הריצה.
TempData: מידע שנשמר בין גלישות
ViewData ו-ViewBag מעבירים מידע רק בגלישה הנוכחית. אם רוצים להפנות את הלקוח לדף אחר, למשל דף תודה אחרי שמירה, משתמשים ב-TempData. המידע נשמר בשרת לבקשה הבאה בלבד, ואחר כך נמחק. בדוגמה, הקונטרולר שומר את שם המשתמש ב-TempData ומחזיר RedirectToAction לדף תודה. בדף התודה מציגים הודעה כמו Thanks, Moishe, your operation was successful.
שימו לב
בחירת השיטה תלויה במה שצריך: מודל לתוכן הראשי, ViewBag או ViewData למידע נוסף בגלישה אחת, ו-TempData כשהלקוח מנותב לדף אחר.
השיעור הבא בקורס: שפת Razor לכתיבת View
מילון מושגים:
קוד מקור - הקוד שמפתחים כותבים בשפת תכנות, לפני הידור, המגדיר את פעולת התוכנה.
MVC - דפוס ארכיטקטורה שמפריד יישום לשלושה חלקים: מודל (נתונים), תצוגה (View) ובקר (Controller).

להורדת קוד מקור של כל הדוגמאות בקורס MVC – לחץ כאן


פרקי ההרצאה: העברת מידע מ-Controller ל-View

  1. 00:00

    למה מעבירים מידע ל-View

  2. 00:53

    יצירת Products Controller ומוצר

  3. 01:49

    Strongly Typed View למודל הראשי

  4. 03:08

    הצגת נתוני המוצר ב-View

  5. 04:52

    מידע נלווה עם ViewData

  6. 06:58

    גישה ישירה למפתח ב-ViewData

  7. 07:39

    משתנה Dynamic בשם ViewBag

  8. 09:58

    סיכום השיטות ומידע בין גלישות

תמלול ההרצאה: העברת מידע מ-Controller ל-View

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

  1. 00:01

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

  2. 00:14

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

  3. 00:24

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

  4. 00:36

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

  5. 00:47

    דבר ראשון, יש לנו כאן במודל מודל אחד שנקרא product, יש לו product ID, יש לו product name ויש לו price. בואו נצרף קונטרולר, נלך ל-add, פרודקט קונטרולר ונבנה לנו product controller product controller נבנה פה איזושהי פונקציה get some product הפונקציה הזאת ניגשת

  6. 01:16

    לדאטאבייס מוציאה מהדאטאבייס איזשהו מוצר שהלקוח רוצה אנחנו כרגע נבנה אותו product p שווה new product נאכלס אותו בנתונים product name ביסלי, פרייס, 3.4, דצימל, פרודקט איי-די, 100. נניח שזה המוצר שהבאנו מהדאטה-בייס.

  7. 01:50

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

  8. 02:02

    בואו ניצור view כרגע, add view, get some product, אנחנו יכולים להגדיר create a strongly type view, אנחנו כאן יכולים להגדיר את הטיפוס נתונים שהמודל מתעסק איתו.

  9. 02:22

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

  10. 02:49

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

  11. 03:18

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

  12. 03:45

    ברגע שאנחנו עושים נקודה, אנחנו מקבלים את ה-product name, אנחנו יכולים להציג פה html רגיל, נרד בשורה, נציג את ה-price, נרד בשורה, ונציג את ה-id.

  13. 04:20

    אוקיי, אז יש לנו את הפונקציה get some product, בואו נגלוש לאתר שלנו, קונטרולר פרודקטס פונקציה get some product ואנחנו רואים שהצלחנו להעביר את המידע בשיטה הסטנדרטית בין הקונטרולר לבין ה-view ואז ה-view הציג אותו אבל זה המידע הראשי שקיים ואותו אנחנו רוצים להציג זה המידע המרכזי שאנחנו רוצים להציג מה קורה אם אנחנו רוצים בנוסף

  14. 04:56

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

  15. 05:12

    בשביל להעביר מידע נוסף, יש לנו מספר שיטות. השיטה הראשונה נקראת viewData. viewData למעשה זה Dictionary, כלומר קולקשן שמקבל ערכים שהם Key ו-Value. כל ערך שאנחנו מוסיפים לקולקשן, אנחנו צריכים לספק לו איזשהו מפתח שהוא חייב להיות ייחודי, ואת המידע עצמו שהוא צמוד למפתח.

  16. 05:39

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

  17. 05:58

    אוקיי, איך אנחנו מוצאים אותו מה-view? אז בואו נלך ל-view ופה למעלה נגדיר span של user name וכל מה שאנחנו צריכים לעשות זה לגשת על ידי שטרודל ל-view data ובסוגריים מרובעות אנחנו ניגשים ומוצאים את המידע על ידי המפתח הייחודי שנתנו לו user name בואו נראה את כאן שורה או שתיים נריץ נגלוש לאותה פונקציה ונראה כרגע שהקונטרולר

  18. 06:41

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

  19. 07:05

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

  20. 07:33

    get some product ונראה שהמידע הגיע בצורה תקינה כמו מקודם אבל עכשיו עכשיו ראינו שתי שיטות להעברת מידע מהקונטרולר ל-View.

  21. 07:45

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

  22. 08:07

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

  23. 08:27

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

  24. 08:42

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

  25. 09:19

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

  26. 09:36

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

  27. 09:56

    אז עד עכשיו ראינו שלוש שיטות. השיטה המרכזית, העברת המידע הראשי ל-View. שיטה שנייה, העברת מידע נלווה על ידי ViewData באחת משתי צורות.

  28. 10:09

    שיטה שלישית העברת המידע על ידי view-bag גם הוא מידע נלווה וזאתי שיטה קצת יותר חדשנית אבל מה קורה אם אנחנו רוצים להעביר מידע בין מספר גלישות בין הלקוח לשרת מה זאת אומרת נניח שיש לנו איזושהי פונקציה שהלקוח רוצה לקרוא לה והיא מבצעת איזושהי שמירה בדאטאבייס של איזשהו מידע בואו ניקח פונקציה

  29. 10:38

    נחזירה action result

לקורס המלא: קורס MVC אונליין בעברית

ההרצאה הקודמת: החזרת ערכים מה-Controller

ההרצאה הבאה: שפת Razor לכתיבת View

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

  • Media Controller
  • העברת מידע בין קומפוננט אב לתתי-קומפוננטות שלו - ילדים ב-REACT
  • VIEW עם Check
  • Debug View

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

  • קורס Entity Framework Core - עבודה עם מסד נתונים בדוט-נט
  • קורס דוט-נט - NET Core. - עם Rest API
  • קורס ASP.NET
  • קורס Git ו-GitHub עם Visual Studio