PracticU

Serialization - חלק 1

בלי כתוביותעם כתוביות
PracticU › קורס תכנות מתקדם - #Advanced .NET C › Serialization - חלק 1
מילון מושגים:
בנאי - מתודה מיוחדת שמופעלת אוטומטית בעת יצירת אובייקט ממחלקה, ומאתחלת את ערכיו ההתחלתיים.
בינארי - ייצוג מידע בבסיס 2 בעזרת הספרות 0 ו-1. גם קובץ הכולל קוד מכונה ולא טקסט קריא.
חריגה - מצב שגיאה שמתרחש בזמן ריצת התוכנית ומפסיק את המהלך הרגיל, אלא אם הקוד תופס ומטפל בו.
מאפיין - תכונה שמצמידים לרכיב ומתארת אותו או את התנהגותו, למשל מאפיין של תגית HTML או שדה באובייקט.
DLL - קובץ ספרייה ב-Windows המכיל קוד ופונקציות שתוכנות שונות יכולות לטעון ולהשתמש בהן במשותף.
XML - שפת סימון לייצוג נתונים מובְנים בעזרת תגיות, המשמשת להחלפת מידע בין מערכות ולקובצי הגדרות.
תגית - סימון בקוד, למשל ב-HTML, שתוחם רכיב ומגדיר את תפקידו או תכונותיו. גם תווית לסימון וקיטלוג פריטים.
חומת אש - מערכת שמסננת תעבורת רשת לפי כללים, ומתירה או חוסמת חיבורים כדי להגן על מחשב או רשת.

Serialization - חלק 1
Serialization מאפשר לקחת אובייקט, גם מורכב כמו קולקשן גדול, ולשפוך אותו אוטומטית דרך סטרים, למשל לקובץ, ולטעון אותו בחזרה בהרצאה הבאה בלי לכתוב קוד שמירה בעצמכם. ההרצאה מדגימה זאת על מחלקה Person בשני פורמטים.
השלבים העיקריים
1. הרעיון: סטרים הוא קו תקשורת בין שתי נקודות, לא רק קובץ. אפשר לשפוך אובייקט בצד אחד ולקבל אותו בצד השני. אם הסטרים מצביע על קובץ, האובייקט נכנס לקובץ, ואפשר לטעון אותו בחזרה לאובייקט.
2. מחלקת Person: שדות first name, last name ו-age, קונסטרקטור ו-ToString.
3. שמירה בפורמט בינארי: פותחים FileStream ליצירת קובץ (Person.bin) ויוצרים BinaryFormatter. קוראים ל-Serialize עם הסטרים והאובייקט, ובסוף סוגרים את הסטרים.
4. חריגה בלי Attribute: ההרצאה מציגה שגיאה שאומרת ש-Person אינה מסומנת כ-serializable. הפתרון הוא להוסיף מעל המחלקה את ה-Attribute [Serializable].
5. טעינה: פותחים סטרים לקריאה (File.OpenRead), יוצרים BinaryFormatter וקוראים ל-Deserialize. היא מחזירה object, ולכן עושים casting ל-Person. אפשר לבדוק בדיבאגר שהמידע נטען.
6. פורמט SOAP: מוסיפים reference ל-DLL בשם System.Runtime.Serialization.Formatters.Soap ומשתמשים ב-SoapFormatter במקום ב-BinaryFormatter. הקובץ נשמר כ-XML (למשל Person.xml) וניתן לקריאה בדפדפן או ב-Notepad, עם תגיות כמו FirstName ו-LastName. SOAP הוא קיצור של Simple Object Access Protocol.
7. שדה שלא נשמר: מעל שדה שלא רוצים לשמור, למשל age, שמים [NonSerialized]. בקובץ לא מופיעה תגית age, ואחרי טעינה הגיל הוא 0.
8. שדה חדש וקובץ ישן: אם מוסיפים שדה (בדוגמה address) וטוענים קובץ שנשמר לפני כן, מתקבלת חריגה שאומרת שיש 3 members ובקובץ רק 2. הפתרון: [OptionalField] מעל השדה החדש, וכך הוא נטען אם קיים והתעלמות אם לא.
הבדלים בין Binary ל-SOAP
1. קריאות: SOAP הוא טקסט שאפשר לפתוח וקרוא, ובינארי לא.
2. גודל: SOAP גדול יותר, הבינארי קטן יותר.
3. העברה: קבצי XML עוברים בקלות Firewall ונשלחים באימייל, וקובץ בינארי עלול להיחשד.
4. Generics: הבינארי תומך ב-generics (למשל List), ו-SOAP לא.
5. המחלקה וקשריה: כל ה-Data Members, גם בתוך אובייקטים אחרים, וגם מחלקות בסיס, חייבים להיות serializable. אחרת מסמנים את הרכיב [NonSerialized].
שימו לב
המטרה היא גם לשמור מידע בין הפעלות של האפליקציה (persistent), וגם לשלוח אותו לאדם אחר.
אחרי ההרצאה אפשר לשמור אובייקט לקובץ ולטעון אותו, לבחור בין בינארי ל-SOAP ולשלוט במה נשמר.
השיעור הבא בקורס: Serialization - חלק 2

פרקי ההרצאה: Serialization - חלק 1

  1. 00:00

    מהו Serialization

  2. 01:05

    העברת אובייקט דרך Stream

  3. 02:39

    בניית מחלקת Person

  4. 04:59

    שני רכיבי Serialization בדוטנט

  5. 06:24

    שימוש ב-BinaryFormatter

  6. 08:09

    הרשאת Serializable Attribute

תמלול ההרצאה: Serialization - חלק 1

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

  1. 00:03

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

  2. 00:23

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

  3. 00:33

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

  4. 00:49

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

  5. 01:02

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

  6. 01:31

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

  7. 01:42

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

  8. 01:52

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

  9. 02:21

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

  10. 02:43

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

  11. 03:09

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

  12. 03:44

    בואו נבנה כאן פונקציית toString שמחזירה את השם המלא first name ו-last name ואת ה-h. אוקיי, אז יש לנו את המחלקה person ואנחנו יכולים עכשיו ליצור אובייקט ממנה.

  13. 04:06

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

  14. 04:37

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

  15. 05:11

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

  16. 05:38

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

  17. 05:55

    בכדי שבוודאות אנחנו נצליח לפתוח את זה בתיקייה של קובץ האפליקציה, אולי כדאי שנצרף את ה-reference system windows forms ונשתמש באפליקיישן.

  18. 06:17

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

  19. 06:44

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

  20. 07:02

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

  21. 07:17

    ואז פונקציית serialize אומרת לי, כן, בבקשה, הנה תביא לי סטרים, יש לנו stream to write, ותביא לי את האובייקט שאתה רוצה, קראנו לו p, וזאת כל הפעולה.

  22. 07:30

    אנחנו צריכים כמובן לבצע dispose או closing לסטרים שלנו. עכשיו אם אנחנו הולכים להריץ את זה אנחנו הולכים לקבל exception שימו לב איפה על פונקציית ה-serialize וה-exception מציינת שאנחנו לא יכולים לבצע את פעולת ה-serialization על person מפני ש-Person is not marked as serializable.

  23. 08:10

    מה זה אומר? בכדי לאשר את הפעילות הזאת שאנחנו רוצים לבצע, אנחנו צריכים לתת הרשאה כזאת ל-Person על ידי Attribute Serializable.

לקורס המלא: קורס תכנות מתקדם ב‑#C ודוט-נט

ההרצאה הקודמת: תרגילים על קבצים - Files

ההרצאה הבאה: Serialization - חלק 2

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

  • Object Serialization

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

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