חידושים ב-C# ver 5
Result מה-Task כופה המתנה, ולכן הפונקציה עדיין חוסמת את הלולאה.Result כותבים await לפני ה-Task. הפונקציה מחזירה את הטרד למי שקרא לה, וממשיכה כשה-Task מסתיים.Result. כשנשלפים הערכים כבר רצים במקביל.Task<int>, הקורא יכול לשלוף ממנה את התוצאה רק בסוף.פרקי ההרצאה: חידושים ב-C# ver 5
תמלול ההרצאה: חידושים ב-C# ver 5
הטקסט המלא של הדקות הראשונות בהרצאה «חידושים ב-C# ver 5» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אוקיי אז אחרי שראינו C-Sharp 2 ו-C-Sharp 3 ו-C-Sharp 4 אנחנו מגיעים ל-C-Sharp 5. C-Sharp 5 יצא ב-2012 וכולל בעצם דבר אחד מרכזי שנקרא Asynchronous Programming שכבר אנחנו הולכים לראות מה זה אומר.
שימו לב רק שעברנו מ-Visual Studio 2010 לגרסה של Visual סטודיו 2015 למרות שאפשר לבצע את זה בגרסת 2012 וגרסת 2013 אבל אסינכרוניס פרוגרמינג לא ניתן לביצוע בגרסת visualstudio.net 2010 לכן עברנו כרגע ל-2015 שזה מה שהתקנתי ממש עכשיו במחשב אז בואו נראה מה זה אומר בואו נניח שיש לנו כאן איזושהי
פונקציה static void אני רוצה לבצע חישוב של סכום של מספרים נניח נקבל איזשהו מספר ואני רוצה לבצע חישוב של כל המספרים מאחד ועד המספר ואני מראה פה דוגמא לפונקציה שכביכול אמורה לקחת זמן וחשב את כל המספרים מאחד עד המספר לא אמור לקחת זמן אז אנחנו נבצע איזושהי הדמיה כאילו שזה לוקח הרבה זמן אז בואו נעשה פה איזשהו input sum ניגש לנולד 4 נתחיל
מ-1 עד תנ"ם ומה שאנחנו רוצים לעשות זה פשוט מאוד שם פלוס שווה ל-i. כל הסיפור הזה בוא נניח שלוקח טיפה זמן אז נשים פה איזה spread.clip של שנייה אחת כל פעם שמחשבים לא משנה איזה מספר רוצים לחשב בוא נניח שאנחנו עושים המתנה של שנייה.
לבסוף בואו נציג את המספר. עכשיו בכדי להבין את הכוח של אסינכרונס פרוגרמינג אני רוצה לקרוא לפונקציה הזאתי מספר פעמים. בואו ניגש באיזושהי לולאת for ונרוץ 10 פעמים.
גם כאן נתחיל מ-pad, כל עוד i קטן שווה ל-100. בואו נלך עד 10 ומה שנעשה זה פשוט נקרא לפונקציה calc, נגיד את זה בתוכה עם את הקריאה Calc Summary ואני רוצה לשלוח לה את i כפול 10. אם אנחנו נריץ עכשיו את התוכנית, כמובן כל הסיכום הזה יתבצע במשך 10 שניות וכל
פעם שהפונקציה מסיימת לבצע את החישוב היא כמובן תציג את תוצאת הסכום על המסך ואנחנו הולכים לראות את התוצאות מוצגות במרווחים של שנייה בואו נריץ ואנחנו רואים 10 20 30 למרות שזה לא אמור להיות הנתונים האלה כן אני כבר רואה מה לא בסדר, הייתי צריך להציג את הסכום בעסיקלי,
נריץ, נראה עכשיו את הסכומים עצמם, או נראה יותר הגיוני, אנחנו רואים שזה מתבצע כל שנייה, וכמו שאנחנו רואים הפונקציה הזאת היא בכלל לא אסינכרונית, היא פונקציה סינכרונית רגילה לגמרי, זה אומר אם אנחנו קוראים לה המערכת ממתינה עד לסיום הפונקציה.
אנחנו רוצים להפוך את הפונקציה הזאת לקריאה אסינכרונית, מה זה אומר? זה אומר שאנחנו רוצים לקרוא לה ואנחנו רוצים שהמערכת שקוראת, כלומר הפונקציה שקוראת לקלק סאמרי, זה אומר המיין, מיד אחרי שהיא קראה לקלק סאמרי תמשיך ותעשה עוד דברים.
במקרה שלנו תמשיך בלולה. זאת אומרת אנחנו רוצים לקרוא לקלק סאמרי ממש עשר פעמים במהירות בכדי שהיא תתחיל לעבוד. כמו שהתחלנו להסביר בהתחלה אסינקרוניס פרוגרמינג מתבצע על ידי task.
זה אומר שאנחנו צריכים בתוך הפונקציה קודם כל לבנות לעצמנו task אז בואו נבנה task t שווה new task ונגדיר שהtask הזאת תעשה את פעילות שאנחנו רואים כאן זאת אומרת אנחנו רוצים שהtask basically תבצע את כל הסיפור הזה יש לנו פה צורך לסגור את הפוגריים של התask נקודה פסיק בצורה כזאת עכשיו מה שאנחנו רואים כאן זה שהtask מבצעת איזושהי פעולת חישוב יותר רלגנטי יהיה
שהטאסק פשוט תחזיר לנו את תוצאת החישוב זה יהיה כמובן החזרה של int מבצע את ההחזרה מפה עכשיו אנחנו יכולים לקחת את הקריאה את הטאסק בואו ניקח משתנה אחר שלא נתבלבל ביניהם את t.reason ונציג פה בחוץ את ה summary אנחנו עדיין בתוך הפונקציה talk summary אבל אנחנו מחוץ לפונקציה של הטאסק זאת אומרת השלב הראשון שהיינו צריכים לעשות ביצירת פונקציה
אסינכרונית, כלומר פונקציה Calc Summary כפונקציה אסינכרונית, הדבר הראשון זה ליצור Task בתוך הפונקציה. אם ה-Task צריכה לבצע לי פעולת יישוב מן הראוי שהיא תחזיר אותה, אין שום בעיה שתחזיר.
ה-Task עצמה לוקחת זמן כי בתוך ה-Task יש לנו את ה-thread.slip, פה אנחנו רואים שיש לי איזושהי פעולה שכמובן לוקחת זמן, ואז אנחנו מתחילים את הטאסק, עדיין בתוך הפונקציה, מקבלים את התוצאה ומציגים את התוצאה בפונקציה.
האם כרגע הפכנו את הפונקציה לאסינכרונית? בואו נריץ ונראה את ההדפסות במרווחים של שנייה. הפונקציה לא תוכל להיות אסינכרונית. והשאלה למה? יש בתוכה טאסק.
והתשובה, כאשר למדנו על טאסקים, ראינו שכאשר אנחנו משתמשים בריזולט, שזה בדיוק מה שאנחנו רוצים לעשות כרגע, אז אנחנו נאלצים להמתין. אבל רגע, מי זה אנחנו נאלצים להמתין?
הפונקציה CalcSummery. שם, בתוך הפונקציה CalcSummery, יש P.L.Result, ובדיוק בשורה הזאת יש כאן Raping for the task.
בול כאן. זה אומר שאנחנו נאלצים להמתין, ובגלל זה CalcSummery עדיין לא נחשבת כאסית כרונית, היא עצמה תוקעת לנו את ריצת התוכנית. אז איך אנחנו הופכים את Calc Summary ל-Async רונית?
כל מה שאנחנו צריכים לעשות זה סך הכל שני דברים. דבר ראשון, אנחנו צריכים להגיע פה לחתימה של הפונקציה ולכתוב את הפקודה async.
זאת מילה שמורה שהתווספה רק ב-C-Sharp 5. פה אנחנו כותבים async ושימו לב שקיבלנו איזושהי הערה על Calc Summary וההערה אומרת שחסרה לנו עוד מילה אחת שנקראת ה-wait.
אוקיי, את ה-await אנחנו מגדירים כאן. כאשר אנחנו משתמשים ב-await אנחנו לא צריכים להשתמש ב-t.result אלא אנחנו חייבים להגדיר ה-wait ל-t.
זאת אומרת אנחנו ממתינים ל-t שה-task תסתיים בדיוק בנקודה הזאת וכאשר היא מסתיימת פקודת ה-wait לא מחזירה את ה-task אלא מחזירה את ה-result של ה-task. זאת הסיבה שאנחנו מגדירים פה סאמרי והכל נראה בסדר גמור.
הריזולט של הטאסק נכנסת לתוך הסאמרי כי הריזולט זה אינטג'ר מפני שהטאסק הוגדרה פה כאינטג'ר והכל עובד כמו שצריך מבחינת קומפיילר. אז בייסיקלי תכנות אסינכרוני אומר שימו פה את המילה async בכותרת של הפונקציה, כאשר אתם רוצים להמתין לטאסק שימו את המילה await, לרשום t נקודה ריזולט אלא רק await ל-t לאובייקט
task שלכם ותחזירו את הערך הזה למשתנה שהוא מהטיפוס של הריזולט. אוקיי זה מבחינה טכנית מה קורה בפועל? מה שקורה בפועל זה שהפונקציה עכשיו calc summary הפכה להיות לפונקציה אסינכרונית.
זה אומר שכאשר אנחנו קוראים לה אז הtask מתחילה להתבצע וברגע שאנחנו מגיעים ל-await קורים פה שני דברים דבר ראשון הפונקציה עצמה הפנימית ממתינה מה שכתוב פה הוא waiting ועדיין נכון מפני שאנחנו לא יכולים להשתמש בריזולט לפני שהפעולה הסתיימה אבל הדבר השני שקורה כאן הוא משחרר לנו את הקולינג טרד את הטרד הזה שקורה
שחרר אותו ואנחנו יכולים להמשיך לרוץ למעשה הוא ממש כבר בהתחלה השתחרר אנחנו יכולים לרוץ ולבצע את כל הקריאות האלה שוב ושוב ושוב וכאשר הטאסקים יפיקו אז המערכת תדע לחזור לכאן ולבצע את ההדפסה עם התוצאה.
בואו נריץ ונראה איך עכשיו התוכנית מתנהגת. אז אני מריץ את התוכנית ושימו לב שקודם כל הכל הסתיים ואנחנו לא רואים שום דבר ואנחנו צריכים להזכיר שהסיבה שאנחנו לא רואים היא בגלל שטאסק ביי דיפולט מוגדרת כ-Background Thread היא משתמשת ב-Threadpool ש-Threadpool הטרדינג שלו זה-Background ולכן המיין נגמר ואוטומטית כל ה-Threadpool הפסיק
לעבוד אז רק בשביל לראות שבאמת הדבר הזה מייעל לנו אנחנו צריכים לבצע פה איזשהו console.readline רק בשביל לעצור את ה-console כמובן לא היינו חייבים לעשות את זה אם היינו בעצם באמצע תוכנית ולא היינו צריכים להמתין לאף אחד בואו נריץ ונראה כעת שההדפסות הן הרבה יותר מהר וזהו זה הסתיים, זה לקח הרבה יותר מהר מעשר שניות
ואנחנו רואים גם שזה התבצע בחבילות כאלה מפני שכל טאסק בגלל שנפתחו לנו פה מספר טאסקים אבל שימו לב רק שזה לא התבצע בצורה סינכרונית ואנחנו אפילו יכולים לראות את החדר שלהם שימו לב 55 210 ואז היה אמור להיות 465 כי זה אמור להיות בחדר עולה אבל פתאום קפצנו פה 820 ואז 465 זאת אומרת החישוב
של 820 הספיק להתבצע או להיות מוצג על המסך לפני חישוב של ה-465 אם אנחנו מתעסקים עם פעילות אסינכרונית אנחנו לא מתעסקים עם פעילות סינכרונית מן הסתם אז אנחנו לא יכולים להיות בטוחים שכל הסיפור הזה רץ לפי הסדר.
אבל זו הפעילות הסינכרונית. בפעילות הסינכרונית אנחנו נהנים מזה שזה מתבצע במקביל, אנחנו לא נהנים מזה שזה מתבצע בטור. במקרה הזה אנחנו לא רוצים בכלל שזה יתבצע בטור, כי לא אכפת לנו על הסדר עצמו. אם הייתי רוצה שזה יתבצע לפי הסדר, כמובן הפעילות הסינכרונית לא הייתה מתאימה לי בכלל.
אנחנו יכולים לראות גם כאן שה-2, 4085 הודפס אחרי ה-3240 כנ"ל פה 4095 לא דווקא 4095 הודפס במקום שלו אבל אנחנו רואים פה את הסוויץ' הזה זאת אומרת זה פעל הרבה יותר מהר אנחנו יכולים להריץ ולראות כל פעם שנריץ שימו לב את הצ'אנקים של ההדפסות והופה זה הסתיים הפכנו את הפונקציה לאפינכונית והצלחנו לבצע
את הקריאות חוזרות ונשנות האלה. עכשיו ישנה מוסכמה שאומרת שאם הפכתם את הפונקציה שלכם לאסינכרונית על ידי פקודת אסינק תסיימו אותה במילה אסינק.
ברגע שרואים את הסיומת אסינק אז בעצם ישר יודעים שהפונקציה הזאת היא פונקציה אסינכרונית ואז יודעים שאם אנחנו קוראים לה פעילות ממשיכה ומנהל מוסכמה כזאת לא חייבים לעשות את זה אבל זה קצת יותר נכון מבחינת קונבנשן.
עכשיו אני רוצה לבצע שיטה נוספת בואו ניקח את הפונקציה הזאת ונקרא לה calc summary 1 async, נפיק אותה כדי שהפונקציה תישמר לכם בתרגילים