PracticU

שימוש ב-Cache - חלק 2

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

בשיעור זה מעמיקים בשמירת דפים שלמים וחלקים מהם במאגר השמירה של השרת, רואים איך מפחיתים ייצור מיותר של דפים עבור מספר גולשים, מגלים שהשמירה מותאמת אוטומטית לפרמטרים של הפעולה, ולומדים לשמור רק חלק קטן מהדף בעזרת view חלקי.
נושאי הסיכום המוצגים בשיעור:
1. הרעיון של שמירת דף שנוצר: כשלקוח גולש לתצוגה מתבצעת שפת התבנית ופעולה שטוענת מידע מהדאטאבייס ומייצרת את הדף, וכל זה לוקח זמן, ואם לקוח אחר ממקום אחר בעולם גולש לאותו דף, למה לייצר את הדף פעמיים, אפשר לייצר אותו פעם אחת ולתת אותו גם ללקוח הראשון וגם לשני.
2. היתרון בהצגת הרעיון בדף HTML: הדף שמיוצר בסוף בצד השרת הוא HTML טהור, והוא יכול להישמר בצד השרת, כך שמי שמבקש את אותו דף בדיוק לא צריך לייצר אותו שוב, להריץ את הפעולה, לפנות לדאטאבייס או לעשות כל פעולה אחרת, אלא מקבל את התוצאה שכבר נוצרה, וזה מייעל משמעותית את הגלישה לשרת.
3. ההדגמה שכל גלישה מייצרת מחדש: כדי להוכיח את הבעיה מגדירים בפעולת האינדקס הודעה שמציגה את שעת יצירת הדף, ובתצוגה מציגים אותה, ורואים שכל גלישה מציגה שניות אחרות, כלומר כל פעם שגולשים לפעולה היא מתבצעת מחדש ומייצרת את התצוגה, ואם הייתה גלישה לדאטאבייס היא הייתה מתבצעת בכל פעם.
4. המטרה לשמור את הדף בשרת: רוצים שללקוח הראשון שגולש הדף ייווצר, ושללקוחות הבאים שהדף לא תלוי בהם הפעולה לא תתבצע בכלל ואוטומטית יוחזר התצוגה הקודמת שכבר שמורה בשרת.
5. למה צריך פרק זמן שמירה: לא הגיוני להשאיר את הדף לנצח בשרת, כי אז כל הלקוחות עד הנצח יראו את הדף שלקוח הראשון גלש, ואם הוא ראה רשימת מוצרים לעולם לא יראו רשימה מעודכנת יותר, ולכן מגדירים מספר שניות שבהן הדף ישמר בשרת, ואחריהן הדף יימחק ולקוחות חדשים יקבלו דף חדש ומעודכן.
6. Output Cache עם Duration: השיטה הזאת נקראת Output Cache והיא מתבצעת באמצעות מאפיין בשם זה, וכשמגדירים אותו חייבים להגדיר לו משך זמן בשניות, ובהדגמה עם שלושים שניות רואים שבכל גלישה בטווח הזמן הזה מתקבל אותו דף עם אותה שעה, ורק אחרי שלושים שניות הדף נוצר מחדש, וזו שיטה ששומרת את התצוגה במאגר השמירה כדי שלקוחות אחרים לא יצטרכו לייצר את אותו תצוגה, ושמירת דף שלם נקראת full page caching.
7. מיקרו קאשינג: שמירת הדף למשך שנייה או שתיים נראה מעט, אבל שמירה למספר קטן של שניות נקראת מיקרו קאשינג, וכשיש מאות גולשים בכל שנייה זה כבר משמעותי, ושמירה לשניות קצרות הגיונית רק כשיש המון המון גולשים, ואם אין הרבה גולשים הדבר עשוי להיות מיותר.
8. דף שתלוי בפרמטר: עוברים לדף הפרטים שמקבל מזהה, ומציגים בו הן את ההודעה של שעת היצירה והן את המזהה שהתקבל, וכאן עולה הבעיה שהדף סביר שתלוי במזהה, ולא הגיוני שלקוח ששלח מזהה אחד יקבל את הדף שנוצר עבור מזהה אחר.
9. שמירה כתלות בפרמטר: כאשר פעולה מקבלת פרמטר השמירה נעשית אוטומטית כתלות בפרמטר, כלומר דף עבור מזהה אחד נשמר רק עבור אותו מזהה, לקוח שגולש עם מזהה אחר מקבל דף חדש, שני הדפים נשמרים בשרת, ולקוח שלישי ששוב מבקש את המזהה הראשון מקבל את הדף השמור שלו, ו-MVC מטפלת בזה בצורה אוטומטית.
10. ההדגמה של שמירה לפי מזהה: בהדגמה גולשים לדף הפרטים עם מזהה אחד ורואים שכל גלישה עם אותו מזהה מחזירה את אותה שעה, גלישה למזהה שני יוצרת דף חדש עם שעה משלו, חזרה למזהה הראשון בטווח הזמן מחזירה את הערך השמור שלו, ואחרי חצי דקה הדף מושלך מהמאגר ומיוצר דף חדש, וכך התצוגה נשמרה במאגר הפלט כתלות בפרמטר שנשלח.
11. מקרה של דף גדול עם אזור משתנה: מה קורה כשמציגים ללקוח דף עמוס בנתונים אבל רק אזור אחד קטן בו רוצים לשנות, למשל דף שלם של מכירה פומבית שבו רק טבלה קטנה מראה את המחירים האחרונים, ואז את הדף הגדול רוצים לשמור במאגר ואת המידע הקטן מביאים מהתצוגה כמידע עדכני.
12. המקרה ההפוך, שמירת רק חלק מהדף: יש גם מקרה שבו רוצים לשמור במאגר רק חלק קטן מהדף, למשל תת-תפריט שאינו משתנה כל יום או יומיים, ורוצים שרק הוא יישמר ולא הדף השלם.
13. יצירת פעולה לתת התפריט: יוצרים פעולה שתחזיר את תת התפריט, מגדירים בה את רשימת הפריטים בשקית התצוגה ומחזירים תצוגה חלקית.
14. תצוגה חלקית ושילוב בלייאוט: יוצרים תצוגה בשם זהה לפעולה ומגדירים אותה כתצוגה חלקית שמציגה רשימה לא ממוספרת של כל הפריטים, ואז משלבים את תת התפריט בלייאוט הכללי, ממש מעל הצגת גוף העמוד, בעזרת פקודת HTML שקוראת לפעולה שמחזירה את התצוגה החלקית, והגלישה מראה את התפריט המשני במקום.
15. שמירת התצוגה החלקית במאגר: כדי לשמור רק את התפריט חוזרים ליצירת התצוגה החלקית ומגדירים מעליה את מאפיין השמירה עם משך זמן, למשל שעה שלמה, ומרגע זה לא משנה איזה תצוגה או איזה לקוח או כמה לקוחות או כמה פעולות ירצו לקבל את התצוגה החלקית הזאת, MVC תשמור אותה כמאגר פלט למשך הזמן שהוגדר.
16. המסקנה מהשיטה השנייה: כך אפשר לשמור חלקים של הדפים שלנו שאנחנו לא רוצים שישתנו כחלקים בתוך מאגר הפלט, בלי צורך לשמור כל הזמן את כל הדף או חלקים אחרים ממנו, וזו שיטה שנייה לשמירת דפים שלמים או חלקים של דפים במאגר השמירה באמצעות אובייקט ה-Output Cache.
סיכום:
בשיעור זה הרחבנו את השימוש במאגר השמירה מעבר לאובייקטים ועד לשמירת דפים שלמים שנוצרו בשרת, ראינו איך מאפיין ה-Output Cache עם משך זמן מונע ייצור מחדש של אותו דף לכל הגולשים, גילינו שהשמירה מותאמת אוטומטית לפרמטרים של הפעולה כך שלכל מזהה נשמר דף משלו, הכרנו את מושג המיקרו קאשינג לעומקי עומס גבוהים, ולמדנו לשמור רק חלק מהדף בעזרת תצוגה חלקית שמשולבת בלייאוט ומשמרת זמן ייצור משמעותי.
בשיעור הבא נעסוק בנושא שימוש ב-Async Controller.
SR1115HE
מילון מושגים:
קוד מקור - הקוד שמפתחים כותבים בשפת תכנות, לפני הידור, המגדיר את פעולת התוכנה.
MVC - דפוס ארכיטקטורה שמפריד יישום לשלושה חלקים: מודל (נתונים), תצוגה (View) ובקר (Controller).
להורדת קוד מקור של כל הדוגמאות בקורס MVC – לחץ כאן


פרקי ההרצאה: שימוש ב-Cache - חלק 2

  1. 00:00

    שמירת דפים שנוצרו בשרת

  2. 00:56

    View אחד לכמה לקוחות

  3. 01:51

    זמן יצירת הדף ב-ViewBag

  4. 02:58

    הדף נוצר מחדש בכל גלישה

  5. 03:51

    החזרת View שכבר נוצר

  6. 04:30

    הגבלת זמן השמירה בשניות

תמלול ההרצאה: שימוש ב-Cache - חלק 2

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

  1. 00:01

    אז אנחנו הולכים כרגע להשתמש ב-cash בכדי לשמור בתוכו views שלקוח גלש אליו. מה זאת אומרת? כאשר לקוח גולש לאיזשהו view, הרי אנחנו ראינו שיש את שפת ה-razor שמתבצעת ואולי יש איזשהו action שפועל, כלומר כמובן שיש איזשהו action שפועל ברקע, וטוען מידע מדאטאבייס ומייצר בפועל את אותו view.

  2. 00:25

    כל הדבר הזה יכול לקחת זמן, אבל בואו נחשוב, מה קורה אם לקוח אחד מאיטליה גולש לנו לאתר ורוצה לראות רשימת מוצרים? אז הוא גולש ל-controller products, ל-action index, ורואה את הרשימה.

  3. 00:42

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

  4. 01:01

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

  5. 01:30

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

  6. 01:46

    אז בואו נראה איך עושים את זה. בואו ניגש לקונטרולר שיש לנו, ויש לנו פה את פונקציית אינדקס. ומה שאנחנו נעשה בתוך פונקציית אינדקס זה לצורך הבדיקה ניקח view bag ונגדיר כאן איזושהי מסאג' ונרשום Page Rendered at ונרשום בדיוק את הזמן שבו הקונטרולר יצר את הדף הזה.

  7. 02:17

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

  8. 02:40

    ViewBagMessage אוקיי בואו נגלוש לדף הזה ונראה שכרגע הפייג' רנדרד את 5.42.07 מעולה בואו נלחץ enter ואנחנו נראה שעוד פעם איך שגלשנו עכשיו עברו כמה שניות והמספר השניות זה 20 בואו נלחץ עוד פעם enter אנחנו רואים 29 enter 32 זאת אומרת כל פעם שאנחנו גולשים לדף הזה אז הוא נוצר מחדש אם היה גלישה לדאטאבייס אם היה שימוש בדאטאבייס אז עוד פעם היינו

  9. 03:33

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

  10. 03:47

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

  11. 04:17

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

  12. 04:30

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

  13. 04:43

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

  14. 04:58

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

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

ההרצאה הקודמת: שימוש ב-Cache - חלק 1

ההרצאה הבאה: שימוש ב-Async Controller

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

  • שימוש ב-Cache ב-NodeJS
  • Cache object
  • שימוש ב-useEffect - חלק 1
  • שימוש ב-ModelState

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

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