PracticU

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

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

שימוש ב-Cache - חלק 1
ההרצאה מסבירה מהו Cache ב-MVC ואיך שומרים בו נתון משותף, כמו תפריט האתר, כדי לא לפנות לדאטאבייס בכל גלישה.
השלבים העיקריים
1. למה בזיכרון: פנייה לדאטאבייס היא בדרך כלל הפעולה האיטית בתהליך. נתון שזהה לכל הלקוחות, כמו רשימת ערים או תפריט, נשמר בזיכרון השרת ב-HttpRuntime.Cache.
2. בדיקה ב-BaseController: הקונטרולר הבסיסי דורס את OnActionExecuting ובודק אם המפתח menu קיים בקאש. אם לא, הוא טוען את פריטי התפריט מהדאטאבייס ומכניס אותם לקאש.
3. תוקף לנתון: בעת ההכנסה מגדירים מתי הפריט יצא מהקאש. אפשר לקשור אותו לקובץ, למשל XML, או לטבלה ב-SQL, אבל זה דורש הגדרות נוספות שאינן בקורס. אפשר גם זמן מוחלט, כמו 4 בבוקר כל יום, או מרווח זמן מתגלגל, כמו 5 שעות מרגע ההכנסה. אפשר לתת לפריט גם עדיפות.
4. פונקציית הוצאה: אפשר לרשום פונקציה שנקראת כשהפריט יוצא מהקאש. הסיבה מופיעה כ-CacheItemRemovedReason: DependencyChanged, Expired, Removed או Underused. בשלוש הראשונות טוענים את הפריט מחדש.
5. ניקוי ידני: כשמנהל מעדכן את התפריט, קריאה ל-Remove על המפתח מוציאה את הפריט, והגלישה הבאה תטען אותו מחדש.
שימו לב
הקאש משותף לכל הגולשים ולכל הגלישות. נתון בלי תוקף נשאר בקאש ולא מתעדכן מעצמו, ולכן בלי אחד המנגנונים האלה הלקוחות יראו תפריט ישן.
בסוף ההרצאה התפריט נשמר בקאש, נטען מחדש רק כשצריך, והגלישה לא פונה לדאטאבייס בכל פעם.
השיעור הבא בקורס: שימוש ב-Cache - חלק 2
מילון מושגים:
קוד מקור - הקוד שמפתחים כותבים בשפת תכנות, לפני הידור, המגדיר את פעולת התוכנה.
MVC - דפוס ארכיטקטורה שמפריד יישום לשלושה חלקים: מודל (נתונים), תצוגה (View) ובקר (Controller).

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


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

  1. 00:00

    מה זה Cache

  2. 00:36

    Database כצוואר בקבוק

  3. 01:29

    שמירת Views שלמים ב-Cache

  4. 02:05

    תפריט דינמי מה-Database

  5. 03:00

    טעינת התפריט ב-Base Controller

  6. 03:55

    GetMenu ו-HttpRuntime.Cache

  7. 05:38

    הכנסת התפריט ל-Cache

  8. 06:35

    Products Controller לבדיקה

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

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

  1. 00:00

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

  2. 00:23

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

  3. 00:39

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

  4. 00:52

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

  5. 01:05

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

  6. 01:25

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

  7. 01:54

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

  8. 02:15

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

  9. 02:36

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

  10. 02:56

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

  11. 03:16

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

  12. 03:36

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

  13. 03:53

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

  14. 04:08

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

  15. 04:28

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

  16. 04:51

    אם המניו הונל, אנחנו רוצים לגשת לדאטאבייס. בואו ניגש לדאטאבייס ונביא list של סטרינג עם הערכים הנוכחיים של התפריט. שזה home, products, orders, suppliers ו-contact.

  17. 05:27

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

  18. 05:50

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

  19. 06:07

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

  20. 06:31

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

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

ההרצאה הקודמת: יצירת Controller בסיס

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

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

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

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

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