חידושים ב-C# ver 2
delegate ואחריה הפרמטרים.Nullable<T>, שמסומן גם בסימן שאלה אחרי הטיפוס, למשל int?. בודקים HasValue ומקבלים את הערך עם Value, או משתמשים ב-GetValueOrDefault כדי לקבל ברירת מחדל.yield return לכל ערך, והמערכת בונה את האוסף בעצמה.פרקי ההרצאה: חידושים ב-C# ver 2
תמלול ההרצאה: חידושים ב-C# ver 2
הטקסט המלא של הדקות הראשונות בהרצאה «חידושים ב-C# ver 2» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לסדרת התוספות והשדרוגים שהוסיפו ל-C-Sharp 2. חלק מהדברים האלה אנחנו כבר נחשפנו אליהם בעבר, ולכן אנחנו הולכים לעשות אליהם תזכורת מהירה, אבל למה חשוב לנו לדעת שזה בדיוק יתווסף ב-C-Sharp 2,
כזכור ב-2005? כי יכול להיות שאתם עובדים עם איזושהי תוכנה ישנה של איזשהו ארגון שעובדים בפריימוורק 1.0 או פריימוורק 1.1, יחסית זה נדיר, אבל זה יכול להיות.
C-Sharp לא C-Sharp 2 אז תדעו שהיכולות האלה לא קיימות לכם רק מ-C-Sharp 2 והלאה אנחנו יכולים להשתמש בהם. אז מה שהתווסף ב-C-Sharp 2 זאת מחלקה סטטית, מחלקה שהיא פרשל, אנונימוס מתוד כלומר פונקציה אנונימית, כל הקונספט של ה-Generics, כל הקונספט של ה-Nullable Types והמילה השמורה Yield.
אז בואו ניכנס ונראה דוגמה מהירה לכל אחד מהדברים האלה. אז הדבר הראשון שאנחנו הולכים לראות זה בעצם היכולת לבנות מחלקה שמוגדרת כמחלקה סטטית. בואו נלך ונוסיף איזושהי מחלקה שהתפקיד שלה ולעשות פעולות על קולקשנים.
נניח נקרא לה array services, כל מיני שירותים בנוגע למערכים. אנחנו רוצים שיהיה לנו פונקציה שמחזירה לנו סכום של ערכי מערך. בואו נניח נקרא לה getSum, קבל איזשהו מערך, תרוץ עליו, תבצע חישוב של הסכום של הערכים שלו ולבסוף תחזיר.
בנוסף אנחנו רוצים פונקציה שתחזיר ממוצע של ערכי מערך, נקרא לה getAverage והיא תחזיר את סכום ערכי המערך לחלק לאורך המערך ויש לנו עכשיו איזושהי מחלקה שעושה פעולות חישוביות על מערכים אז כאמור בהתאם לחוקים של Object Oriented ולהיגיון של Object Oriented שהוא היגיון די בריא אם יש לנו מחלקה שאין
לה שום Data Member ואני לא צריך להשתמש באיזה שהם Data Members במחלקה אלא יש בה רק פונקציות שנותנות איזשהו שירות אז אין צורך לבנות אובייקט מהמחלקה עצמה בכדי לקרוא לפונקציות.
כאן אנחנו רואים שיש לנו פה איזשהו אובייקט, ואנחנו קוראים לפונקציה לדוגמה getSum ושולחים לה מערך. אבל אין שום צורך וזה מיותר לגמרי לבנות אובייקט מהמחלקה הזאת, אין שימוש ב-dataMembers שלו, לכן כל פונקציה כזאת מן הראוי שהיא תהיה מוגדרת
כסטטית. הנה פונקציה ראשונה סטטית, הנה פונקציה שנייה סטטית, ועכשיו בכדי להשתמש בפונקציות אנחנו יכולים לבוא ולקרוא ל-aray Services נקודה in הפונקציית getSum, in הפונקציית getAverage, אין בעיה שנפתח פה איזשהו מערך ויש לנו בו כל מיני ערכים ואנחנו רוצים להציג את הסכום שלו ואנחנו רוצים להציג את הממוצע שלו.
אפשר להריץ את זה ולראות שיש לנו שני מספרים סכום וממוצע והכל בסדר, יש פה איזה משהו אחד שעדיין קצת לא הגיוני, וזה שמי שמשתמש במחלקה יכול ליצור ממנה אובייקט.
הרי Services, אז מה היה הפתרון? להגדיר את המחלקה כאבסטרקטית? זה לא בדיוק הפתרון, מפני שזה אומר שהיא מיועדת להורשה, ולא בטוח שאני רוצה לרשת מהמחלקה הזאת.
אז הפתרון זה להגדיר את המחלקה כסטטית. סטטיק אומר, א', אי אפשר ליצור ממנה אובייקט, ב', כל מה שיש בתוך המחלקה בעצם חייב להיות סטטי.
יכול להיות במחלקה הזאתי הרבה דברים, יכול להיות שמה data member, זה יכול להיות properties, זה יכול להיות פונקציות, אבל כל מה שקיים במחלקה חייב להיות סטטי לגמרי, מפני שאין צורך ליצור פה דברים ספציפיים במחלקה הזאת שהם לא מוגדרים כסטטיים.
אז כעת יש לנו את היכולת להגדיר מחלקה כסטטית, וזה אומר כל מה שנמצא בתוכה חייב להיות סטטי, אי אפשר ליצור ממנה אובייקט.
הדבר הזה התווסף ב-2005 C-Sharp 2, היכולת הזאת, המילה סטטית על קלאס. הדבר הבא שהתווסף, שאנחנו הולכים לראות דוגמה מהירה שלו, זה הקונספט של פרשל.
פה אנחנו יכולים לבנות מחלקה שפזורה על פני מספר קבצי C-Sharp. בואו ניקח כאן איזשהו דמו, ניקח כאן מחלקה טסט, ויש לנו בטסט public int ניקח value והדבר הזה נמצא באיזשהו קובץ test1.csharp אנחנו יכולים לבנות קובץ csharp אחר לגמרי נקרא לו test2 ועדיין בואו להמשיך ולכתוב את המחלקה test ובואו נכתוב פה
print ונטיס את ערך הvalue נשים אותם רגע side by side נשים פה vertical וvertical בשביל להצליח לעשות את הדבר הזה אז אנחנו צריכים כל מחלקה להגדיר כפרשל.
יש לנו פה את המחלקה הזאת כפרשל, יש לנו את המחלקה הזאת כפרשל, כל אחת חייבת להיות מוגדרת כפרשל ושימו לב שעכשיו אנחנו יכולים לגשת למשתנה ה-value. מה בעצם מתבצע כאן?
מבחינת הקומפיילר, הקומפיילר רואה מחלקה כפרשל אז הוא יודע שיכול להיות קובץ c-sharp אחר שיש בו את המשך המחלקה הזאת.
לכן מה שהקומפיילר מבצע זה לוקח את כל המחלקות שנקראות באותו השם טסט בהקשר הזה מכל הקבצים השונים והופך את כולם למחלקה אחת כאילו שאנחנו באמת כתבנו את המחלקה הזאת פעם אחת בקובץ c-sharp אחד ויחיד.
אם אנחנו נכנסים עכשיו לפרוגרם אז אנחנו יכולים לגשת ולבנות אובייקט מסוג טסט ולראות שיש בו גם value וגם פונקציית print ומבחינת המערכת זה פשוט מחלקה אחת ויחידה. אז השאלה הנשאלת, למה לנו לעשות דבר כזה?
למה לנו לכתוב מחלקה על פני מספר קבצי C-Sharp, שאגב אפשר יותר משתיים, אין פה איזושהי הגבלה מסוימת, פשוט כל מחלקה חייבת להתחיל במילה פרשל.
למה לנו לקחת מחלקה ולפזר אותה על פני מספר קבצים? והתשובה היא, אם אנחנו בונים מחלקה משלנו, לא היינו עושים דבר כזה. זה קצת מקשה על הקריאה של המחלקה וההבנה של איפה נמצאים החלקים השונים.
המערכת משתמשת ביכולת הזאת כאשר היא כותבת לנו משהו שנקרא קוד סינתטי. קוד סינתטי, המערכת מייצרת עבורנו קטעי קוד גדולים, בואו נראה איפה זה מתבצע, ואז אם המערכת, כלומר visualstudio.net, כותבת לנו את הקוד הזה, אז אנחנו לא רוצים שאנחנו נתערב בקוד הזה כאשר
אנחנו כותבים את הקוד שלנו. בואו ניקח פה project windows forms application ונפתח אותו, נראה שיש לנו פה איזשהו טופס.
אנחנו יכולים לכתוב או לעצב את הטופס הזה ולזרוק עליו כל מיני רכיבים ויזואליים. איזשהו לחצן וניקח איזושהי label וניגש לקוד של הלחצן.
ונבצע label1.text שווה לואו. נריץ, נראה שהכל עובד כמו שצריך. אני לוחץ על הלחצן, אני רואה לואו על הלייבל, סבבה.
אבל אם אני מסתכל על הקוד, אני רואה שזה מעט מאוד קוד כתוב שם. כתוב בקובץ הזה, מה גם שאני עוד יכול לנקות אותו טיפה. אז איפה כל הקוד? הרי איפה היצירה של הלחצן והיצירה של הלייבל והכנסה של השמות שלהם וצבעים וכולי?
אז מה שקורה, יש לנו כאן עוד קובץ C-Sharp, form1.designer, אנחנו יכולים להיכנס אליו, ולראות שבקוד הזה יש המון המון פקודות שיוצרות לנו את כל הרכיבים.
אנחנו רואים כאן את הלחצן, ואנחנו רואים את הלייבל, ושימו לב שהמחלקה הזאת היא גם נקראת form1 כמו המחלקה שלנו, אבל היא מוגדרת כפרשל, ואם אני חוזר למחלקה שלנו, אז גם המחלקה שלנו מוגדרת כפרשל, וגם היא form1.
מה קרה כאן? ויז'ואל סטודיו, הדיזיינר של ויז'ואל סטודיו, יצר לנו המון שורות קוד כאשר אנחנו גוררים אליו את כל הערכים שאנחנו רוצים, כל הרכיבים הוויזואליים, אבל אנחנו לא רוצים להתערב בקוד הזה ולכתוב אותו באותו הקובץ שבו אנחנו כותבים את הקוד שלנו.
לכן ויז'ואל סטודיו מפרידה את הקוד הסינתטי הזה לקובץ C-Sharp אחר, ושימו לב שזה פשוט המון קוד, כל הקוד הזה נמצא בתוך איזושהי פונקציה שנקראת Initialize Component, כל ההתחולים האלה, ומהקובץ שלנו ישנה קריאה לפונקציה Initialize Component, כי מבחינת המערכת זאת אותה המחלקה.
כך אנחנו יכולים לקחת את הקוד שוויז'ל סטודיו יוצרת ולזרוק אותו בצד באיזשהו קובץ אחר, ולא לגעת בו, ולא לראות אותו, ולא בטעות להרוס אותו, ואנחנו כותבים קוד נקי רק הקודים שאנחנו כותבים עבור המחלקה שלנו.
הקומפיילר מאחד בין שני הקבצים האלה ויוצר מהם מחלקה אחת. היכולת הזאת להוסיף מחלקה כפרשל, להגדיר מחלקה כפרשל ולחלק אותה על פני מספר קבצים היא יכולת שהתווספה ב-C-Sharp 2 מאוד נפוצה כאשר ויז'ל סטודיו יוצרת לנו קוד סינתטי שזה כמובן במקרים נוספים מאשר ווין פורם. יש כל מיני מקרים שוויז'ל סטודיו כותבת עבורנו קודים.
הדבר הבא שהתווסף ב-C-Sharp 2 נקרא Anonymous Method וזאת פשוט מאוד פונקציה אנונימית. פונקציה אנונימית זאת פונקציה ללא שם, אין לה שם.
כותבים אותה בתוך פונקציה אחרת אבל אם אין לה שם אז איך קוראים לה? איך אנחנו יכולים אחרי שאנחנו כותבים אותה לקרוא לה בשביל שהיא תתבצע? הרי מה המטרה כשאנחנו כותבים פונקציה? שאחר כך נוכל לקרוא לה.
אז פונקציה אנונימית חייבת להיכנס לתוך אובייקט דלגייט. זה אומר שחייב להיות לנו קודם כל איזשהו דלגייט.
בואו נפתח פה דלגייט, ניקח דלגייט שמחזיר דאבל, נקרא לו אופרטור ונגיד שהוא מקבל שני מספרים מסוג דאבל. אם יש לנו דלגייט אנחנו יכולים לבנות אובייקט דלגייט.
אנחנו יכולים להכניס אליו איזושהי פונקציה כלשהי שהיא בעלת אותה החתימה. כרגע נבנה את הפונקציה הזאת כפונקציה חיצונית. בואו ניגש לפה, נבנה static, דאבל, אד, נקרא לזה n1 ו-n2 ונחזיר את n1 ועוד n2.
אוקיי, אנחנו יכולים להכניס את הפונקציה אד בהתאם לקונספט של דלגייטס ולקרוא לפונקציה שלנו בצורה כזאת, יש לנו פה רק צורך בדאבלים בשביל שהחתימה תהיה