PracticU

ViewState

בלי כתוביותעם כתוביות
PracticU › קורס ASP.NET › ViewState
מילון מושגים:
רכיב - יחידת בניין עצמאית וניתנת לשימוש חוזר בתוך מערכת או ממשק משתמש, שאחראית על חלק מוגדר מהתפקוד.
מחלקה - תבנית בתכנות מונחה עצמים שמגדירה אילו נתונים ופעולות יהיו לאובייקטים שנוצרים ממנה.
הצפנה - המרת מידע לצורה בלתי קריאה בעזרת מפתח, כך שרק מי שמחזיק במפתח המתאים יכול לפענח ולקרוא אותו.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
מאפיין - תכונה שמצמידים לרכיב ומתארת אותו או את התנהגותו, למשל מאפיין של תגית HTML או שדה באובייקט.
HTML - שפת הסימון שבה בונים את מבנה ותוכן דפי האינטרנט, באמצעות תגיות שמגדירות כותרות, פסקאות, קישורים ועוד.
טופס - אזור בממשק שבו המשתמש מזין נתונים בשדות ושולח אותם, למשל טופס הרשמה או התחברות.
תנאי - ביטוי לוגי בקוד שתוצאתו אמת או שקר, וקובע אילו פקודות יתבצעו בהתאם לערכו.

ViewState
השיעור עוסק בשמירת מידע בין ריצות חוזרות לאותו דף. הנושא המרכזי הוא ViewState, המנגנון ש-ASP.NET משתמשת בו כדי לזכור מצב של רכיבים וגם מידע שהמתכנת שומר בעצמו.
למה משתנה רגיל לא שומר ערך
בכל ריצה לשרת נוצר אובייקט חדש ממחלקת הדף. משתנה ברמת המחלקה מאותחל מחדש, ולכן ערך שנשמר בלחיצה על לחצן נעלם בלחיצה על לחצן אחר. זה מצב של stateless, כלומר חסר מצב. גם רכיבי ASP.NET נוצרים מחדש בכל ריצה, ולכן לייבל שקיבלה טקסט בלחיצה קודמת יכולה להציג אותו שוב רק בזכות מנגנון נוסף.
ViewState
1. השדה הנסתר: ASP.NET מוסיפה לכל דף input מסוג hidden בשם __VIEWSTATE. הערך שבו מקודד, לא מוצפן, ולכן אפשר לפענח אותו בקלות. הוא מכיל את הערכים של הרכיבים.
2. שמירה ושחזור: כשמשתנה ערך של רכיב, הערך נכתב גם ל-ViewState. בריצה הבאה ASP.NET קוראת את הערך מהשדה ומשחזרת אותו לרכיב, לפני שהאירועים מתבצעים.
3. EnableViewState: מאפיין שקובע אם רכיב נשמר ב-ViewState. ברירת המחדל היא true. כשהוא false, הערך של הרכיב לא נשמר. מאפיין של הדף כולו הוא עוד שכבה, והערך של הרכיב גובר על הערך של הדף.
4. רכיבי HTML רגילים: תיבת טקסט מסוג HTML לא נשמרת ב-ViewState, כי ASP.NET לא יוצרת לה רכיב בשרת. ערך שנשלח בטופס עדיין מגיע לשרת, אבל הוא לא חוזר לדף אוטומטית.
שמירת מידע משלנו
אפשר לשמור מידע משלנו דרך האוסף ViewState: ViewState["ComputerNumber"] = num. בדוגמה של משחק ניחוש בין 1 ל-100, המספר שהמחשב מגריל נשמר בפעם הראשונה שהדף נטען, בתנאי if (!IsPostBack). בכל לחיצה משווים את הניחוש של המשתמש למספר שנשמר.
עומס
כשרכיב עמוס בנתונים, כמו GridView עם טבלת מוצרים, ASP.NET משכפלת את כל הנתונים ל-ViewState. זה מאט את העלאת הדף לשרת, ולכן עדיף לכבות EnableViewState לרכיב כזה כשאין צורך לשמור את הנתונים בין ריצות.
גבול ההיקף
ViewState פועל רק ברמת הדף. מידע ששמור בדף אחד לא זמין בדף אחר.
בסוף השיעור הסטודנט יודע מה נשמר אוטומטית, איך לשמור ערך משלו, ומתי לכבות את EnableViewState.
השיעור הבא בקורס: Session object - חלק 1

פרקי ההרצאה: ViewState

  1. 00:00

    שמירת מידע בין ריצות

  2. 00:42

    מהו ViewState

  3. 01:44

    אובייקט חדש בכל ריצה לשרת

  4. 03:10

    שמירת מספר במשתנה מחלקה

  5. 05:20

    המשתנה חוזר כאפס

  6. 06:18

    איפוס Data Members בכל אובייקט

  7. 08:45

    מצב Stateless של דף

תמלול ההרצאה: ViewState

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

  1. 00:01

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

  2. 00:14

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

  3. 00:30

    הדבר הראשון שאנחנו הולכים לראות נקרא view state. ViewState הינה שיטה אחת לשמור מידע בין ריצות חוזרות ונשנות לאתר על ידי אותו לקוח באותו הדף.

  4. 00:52

    בשביל להבין מה זה ViewState בואו נסתכל קודם כל על משהו מאוד מעניין. אנחנו יודעים שכשהלקוח גולש לדף והוא גולש לדף בעל סיומת ASPX עבור ASP.NET.

  5. 01:09

    ביחד עם הדף הזה יושב לו דף C-Sharp שמחזיק אירועים. האירועים של C-Sharp של הדף מתבצעים בצד השרת. בקובץ ה-C-Sharp ישנה מחלקה, כרגע היא נקראת Home Page, שמנהלת את הדף ובתוכה יש את האירועים הללו.

  6. 01:32

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

  7. 02:05

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

  8. 02:33

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

  9. 02:53

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

  10. 03:18

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

  11. 04:04

    כאשר אני אלחץ על הלחצן המספר 123 הולך להיכנס לתוך המשתנה x שהוגדר ברמת המחלקה. כלומר המשתנה x הוא data member של המחלקה שלנו.

  12. 04:22

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

  13. 05:04

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

  14. 05:31

    ואני רואה שהמספר 0, כלומר המספר 123 כביכול לא נשמר במשתנה. בואו נסתכל רגע מה באמת קרה כאן. לפני זה רק נחליף את הטקסט ל-read number. אוקיי, האם המידע באמת לא נשמר במשתנה?

  15. 06:02

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

  16. 06:23

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

  17. 06:56

    המספר 123 נכנס לתוך המשתנה X, זאת אומרת שאכן בתוך המשתנה X היה מספר 123. אם הייתי מציג כאן את ערכו של X הייתי יכול לראות שאכן יש בו 123. בואו נסתכל על זה. אני לוחץ על Save Number, הצגתי את x ואכן אני רואה 123. אבל מה קרה כשלחצתי על read number ופתאום ראיתי את המשתנה 0. אז אמרנו שבכל פעם שישנה ריצה לשרת נוצר אובייקט חדש מהמחלקה שמשרתת את הדף.

  18. 07:51

    כאשר אני לוחץ על read number זאת גם כן ריצה לשרת, כנ"ל כשאני לוחץ על save number זאת ריצה לשרת.

  19. 07:58

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

  20. 08:18

    אז בריצה של ה-btn-save נוצר x חדש, מוכנס לתוכו 123 וכאן אנחנו יכולים לראות שבאמת הדפסנו את 123. אבל כאשר לחצנו על הלחצן השני ה-x נוצר מחדש עבור אובייקט אחר לגמרי מהמחלקה הומפייג' ולכן ערכו 0.

  21. 08:43

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

  22. 09:07

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

  23. 09:26

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

  24. 09:42

    בואו נסתכל שנייה אחת על דף ה-ASPX שלנו. בדף ה-ASPX שלנו אני עושה משהו בכדי להבהיר את הרעיון. ניקח כאן Label,

לקורס המלא: קורס ASP.NET אונליין

ההרצאה הקודמת: שלושת הקטגוריות של הפקדים

ההרצאה הבאה: Session object - חלק 1

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

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