Reflection - חלק 1
typeof מקבל שם טיפוס, ו-GetType על אובייקט מחזיר את הטיפוס שלו. בשני המקרים מתקבל אובייקט מסוג Type.IsClass, IsValueType, IsAbstract, IsSealed, IsInterface, IsArray. לכל אחד מהם תשובה true או false לפי ההגדרה של הטיפוס.IsPublic מחזיר true רק לטיפוס שחשוף מחוץ ל-Assembly. טיפוס בלי public נחשב internal.Name מחזיר את השם הקצר, ו-FullName את השם כולל מרחב השמות.BaseType מחזיר את הטיפוס הבסיס, IsSubclassOf בודק אם טיפוס הוא נגזרת של אחר, ו-IsAssignableFrom בודק אם אובייקט מסוג אחד יכול להיכנס למשתנה מסוג אחר.פרקי ההרצאה: Reflection - חלק 1
תמלול ההרצאה: Reflection - חלק 1
הטקסט המלא של הדקות הראשונות בהרצאה «Reflection - חלק 1» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא אחר לגמרי והנושא הזה נקרא Reflection. בכדי להבין מה זה Reflection אנחנו צריכים קודם כל להבין משהו בנוגע למה קורה כאשר אנחנו עושים קומפילציה על הקוד שלנו ומהקוד שכתבנו נוצר קובץ הרצה, קובץ Execution או DLL.
אז בואו קודם כל נסתכל על התהליך הזה. אנחנו בעצם בתור מתכנתים כותבים משהו שנקרא Source Code או בעברית קוד מקור. אם אנחנו כותבים ב-C-Sharp אז יש לנו C-Sharp Source Code.
אלה בעצם הקבצים שאנחנו כותבים, קבצי ה-C-Sharp עם סיומת CS. כאשר אנחנו מבצעים קומפילציה, בקיצור מקלדת זה יהיה ב-Visual Studio Control Shift B, אז מכל הקבצים האלה נוצר קובץ אחד ויחיד, או Execution או DLL, מה נקרא .NET Assembly.
אם פתחנו פרויקט קונפר אפליקיישן, Windows Forms Application או WPF Application. אז נוצר לנו קובץ Execution ואפשר ללחוץ עליו Double Click ולהריץ אותו.
אם פתחנו פרויקט מסוג Class Library אז כמובן נוצר לנו DLL והשימוש שלו ניתן לביצוע על ידי פרויקט אחר שהוא DLL אחר או קובץ Execution אחר.
בכל מקרה הקובץ הזה נקרא Assembly וסך הכל אנחנו תמיד יודעים שזה קובץ אחד עם סיומת EXE או DLL. אם זה EXE מישהו יכול ללחוץ עליו Double Click והוא רץ, זאת התוכנית שלנו.
אבל למעשה, מה שחשוב לנו לדעת זה שהקובץ הזה מחולק פנימית למספר חלקים עיקריים. חלק אחד זה בעצם הקוד שאנחנו כתבנו. אם אנחנו כתבנו, נניח, מחלקה שנקראת person, אז הקוד שמרכיב את המחלקה הזאת כמובן חייב להיות בתוך קובץ ה-execution או ה-dll.
זה החלק הראשון והוא נקרא msil. שזה קיצור של Microsoft Intermediate Language. מה זה בעצם הדבר הזה? זאת בעצם שפה שמייקרוסופט המציאה עבור .NET שמשרתת את .NET, קצת דומה לשפה מאוד ישנה שנקראת שפת אסמבלר והקוד של C-Sharp שאנחנו כתבנו מומר לשפה הזאת.
השפה הזאת היא קצת Low Level יותר, אבל עדיין הקוד שכתבנו נמצא אחד לאחד כחלק מהשפה הזאת. המטרה זה שהמנגנון שמריץ את קובץ האקסקיושן שנקרא common language runtime או בקיצור clr יוכל לקרוא את השפה הזאת ולתרגם אותה לקוד המכונה המתאים. זאת הסיבה שבעצם אין לנו פה שפה בקוד מכונה שהמעבד מכיר כלומר ב-0 ו-1 כמו לדוגמה ב-c או c++ שם
הקוד אקסקיושן מורכב ממש מאפס ואחדים שמעבד המחשב ישר יכול לקרוא ולהבין מה רצינו ממנו. פה יש עוד שלב אחד שהCLR מתרגם את השפה המוזרה הזאת, את ה-MSIL לקוד מכונה וכך ברמת העיקרון כל מערכת ההפעלה או כל מכונה אחרת יכולה שיהיה לה סי-אל-אר אחר והם בעצם יתרגמו כל אחד איך
שהוא יודע את קובץ ה-MSIL. זאת הסיבה שעשו פה איזושהי שפת ביניים כזאת. יתרון נוסף שיש ל-MSIL ושלא משנה אם אנחנו כותבים C-Sharp או VB.NET או C++.NET או F-Sharp או כל שפה .NETית אחרת, כולן מתורגמות ל-MSIL.
כך אנחנו יכולים לכתוב מחלקה אחת ב-C-Sharp ומחלקה אחרת ב-VB שלדוגמה יורשת אותה או משתמשת בה. איך זה יכול להיות?
כי בסופו של דבר כל הקודים של .NET כולם הם MSIL, שפה אחת. אז זה החלק הראשון. החלק השני, זה החלק שאנחנו עוסקים בו כרגע בנושא הזה, נקרא מטא-דאטה.
מטא-דאטה זה מונח שאומר נתונים על נתונים, מידע על משהו אחר, מידע נלווה. כאן בעצם יש משהו שנקרא טייפס אינפורמיישן. אם אנחנו כתבנו טיפוס נתונים, נניח כתבנו את המחלקה פרסון.
הקוד של המחלקה פרסון יושב לו בתוך אזור ה-MSIL. אז מה יש באזור המטא דאטה? אינפורמציה לגבי פרסון. המון המון המון דברים שקשורים למחלקה פרסון שכתבנו.
האם זאת מחלקה? האם זה value type או reference type? האם היא מחלקה אבסטרקטית? אילו data members יש לה? אילו פונקציות יש לה? אילו קונסטרקטורים יש לה? ועוד הרבה דברים אחרים.
כל המידע הזה זה לא המחלקה פרסון, זה מידע על המחלקה פרסון וכולו נחשב מטא דאטה. כל טיפוס שאנחנו כתבנו בקבצי ה-C-Sharp שלנו מופיע באזור ה-MSIL, באזור המטא דאטה יהיה אינפורמציה לגבי הטיפוס הזה.
החלק השלישי נקרא Resources והוא מכיל אייקונים, תמונות, מחרוזות ועוד כל מיני דברים שאנחנו רוצים לשתול בתוך קובץ ה-Execution או בתוך ה-DLL כך שהם יהיו חלק מהאקסקיושן ולא קבצים חיצוניים.
אז יש לנו פה את האזור הזה של הריזורסז שמאפשר לנו לעשות את זה. הנושא שאנחנו מדברים עליו כרגע נקרא Reflection ועכשיו אחרי שאנחנו יודעים איך קובץ אקסקיושן או DLL נראה מבפנים אנחנו יכולים בעצם לבצע הגדרה של נושא הרפלקשן.
רפלקשן זה פשוט מאוד היכולת שלנו לקרוא את אזור המטא דאטה במהלך הריצת התוכנית ולבצע עם האינפורמציה הזאת פעולות שונות. הפעולה שבה אנחנו מסוגלים להתבונן באזור המטא-דאטה ולקרוא את מה שכתוב במטא-דאטה זאת הפעולה שנקראת Reflection, כלומר מעין השתקפות כזאת.
אנחנו מסתכלים על המטא-דאטה ואנחנו יכולים לראות בחזרה את האינפורמציה לגבי הטיפוסים ולקרוא את האינפורמציה הזאת. מה אנחנו יכולים לעשות איתה?
זאת שאלה מעניינת. כבר אנחנו הולכים לראות בהדגמות הבאות. אז בואו נצלול להדגמה הראשונה ונראה איך אנחנו מסוגלים לקרוא את המידע ובוא נניח אפילו רק להציג אותו.
אז קודם כל אנחנו צריכים ליצור לעצמנו איזושהי מחלקה. בכדי שיהיה פשוט בואו ניצור מחלקה person יש לנו פה public string full name ובנוסף ניצור לנו איזושהי מחלקה נוספת עובד יורשת את person ויש לנו פה משכורת.
עכשיו אנחנו יודעים שאם אנחנו יוצרים קובץ אקסקיושן מכל הסיפור הזה אז באזור המטה דאטה יש עכשיו נתונים לגבי כל טיפוסי הנתונים שיש לי ויש לנו שלושה טיפוסי נתונים יש לנו את המחלקה פרוגרם יש לנו את המחלקה פרסון ויש לנו את המחלקה אמפלוי אם היה לנו אינם הוא גם היה נחשב טיפוס נתונים כלומר שאנחנו בונים אותו דוגמא Inam Color.
אז אם אנחנו בונים כרגע איזשהו Inam, זה כמובן גם כן טיפוס נתונים חדש שאנחנו בונים. כל הצבעים בטורקיז אלו טיפוסי נתונים שאנחנו בעצם בונים.
כל אחד מהטיפוסי נתונים האלה יופיע באזור המטא דאטה עם אינפורמציה ספציפית לגביו, בלי קשר לכל האינפורמציות האחרות של טיפוסי הנתונים האחרים. טיפוס נתונים ניתן לבנייה מחמש מילים שמורות כמו שאנחנו כבר מכירים.
יש לנו את אינם, יש לנו את סטראקט, יש לנו את קלאס, יש לנו את אינטרפייס ויש לנו את דלגייט. חמשת המילים השמורות האלה יוצרות לנו טיפוס נתונים ועבור כל אחד מהם יהיה לנו אינפורמציה באזור המטא דאטה.
כרגע בנינו רק פרסון ואמפלואי ואנחנו רוצים עכשיו לשלוף את המידע שיש באזור המטה דאטה עבור המחלקה פרסון או עבור המחלקה האמפלואית, תכף נראה.
יש שתי דרכים שאנחנו יכולים לעשות את זה. דרך ראשונה היא פשוט על ידי האופרטור טייפ אוף של דוטנט. טייפ אוף מקבל את הטיפוס הנתונים הרצוי, לדוגמה פרסון, ומחזירה לנו את האינפורמציה.
אבל איך האינפורמציה חוזרת? האינפורמציה תמיד חוזרת לאובייקט מטיפוס טייפ. אז כאן אנחנו רואים שבנינו כאן איזשהו אובייקט מטיפוס טייפ מהמחלקה טייפ והאובייקט הזה תמיד מחזיק את כל האינפורמציה מאזור המטה דאטה של טיפוס נתונים ספציפי.
בעיקרית היא מחזיקה את הנתונים של פרסון. הדרך השנייה זה אם יש לנו אובייקט person p שווה new person וקיים לנו איזשהו אובייקט ממחלקה מסוימת מסוג מסוים. נניח שלחו לנו אותו לפונקציה שבו אנחנו נמצאים או השגנו אותו באיזשהו אופן ואנחנו לא אמורים לדעת אוטומטית מאיזה מחלקה האובייקט הזה קיים.
אז אם הדבר הזה קיים אצלנו, קיים לנו איזשהו אובייקט מסוים, אז אנחנו יכולים לפנות לפונקציה שנקראת get type. get type מחזירה בדיוק מה שהאופרטור type of מחזיר, וזה בעצם שוב פעם אובייקט טייפ מסוג type שמחזיק את האינפורמציה של המחלקה של הטיפוס הזה, המחלקה של האובייקט הזה.
אלה שתי שיטות שבעזרתן אנחנו יכולים לעבוד. אז בואו ניקח את השיטה הזאת ונשים אותה רגע בצד, נשים אותה בהערה ונעבוד עם השיטה הזאת. אז אחרי שהוצאנו את המידע מאזור המטה דאטה כרגע של פרסון אנחנו יכולים להתחיל לחקור ולראות כל מיני דברים לגביו.
אם אנחנו נלחץ נקודה אנחנו נראה שיש לנו פה מלא מלא דברים פונקציות ופרופרטיז שנותנים לנו המון אינפורמציה לגבי טיפוס הנתונים הזה.