Tasks - חלק 3
ContinueWith מגדיר Task שיופעל רק אחרי שה-Task הקודם מסתיים. כך מגדירים את כל הסדרה מראש ומפעילים אותה פעם אחת.Result. כשהפונקציה הראשונה מחזירה מספר, השנייה מציגה אותו.ParallelOptions עם מספר מקסימלי של פעולות במקביל. בהדגמה עם שתיים נראו זוגות הדפסות.פרקי ההרצאה: Tasks - חלק 3
תמלול ההרצאה: Tasks - חלק 3
הטקסט המלא של הדקות הראשונות בהרצאה «Tasks - חלק 3» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
היכולת הבאה שקיימת ב-Task נקראת Continue With. Continue With זה בעצם פונקציה שמאפשרת לנו להגדיר Task א', שרק כאשר מסתיימת מפעילה Task ב'.
בואו נריץ את זה, או ליתר דיוק נפתח קודם כל פרויקט חדש. נגדיר כאן Task T1, יש לנו פה פנייה ל-Do Work 1, והפעלת ה-Task.
לאחר מכן ממשיכים עם ה-Main, b1.wait בכדי שהתוכנית לא תיסגר. יש לנו פה static void do work 1, יש לנו פה do work 1, ואנחנו הולכים לישון שנייה, start do work 1, end do work 1, נבדוק קודם כל שזה עובד כמו שצריך, הכל עובד כמו שצריך.
אבל מה קורה אם יש לנו גם את do work 2, ואנחנו רוצים לבצע את do work 2 רק בסיום do work 1, ואנחנו רוצים להגדיר את הכל מההתחלה. זאת אומרת לפני שבכלל התחלנו את כל התהליך אנחנו רוצים לבצע הגדרה של איזה פונקציות רצות קודם איזה פונקציות רצות אחר כך וסע להתחיל לעבוד עם הכל.
אז מה שאנחנו הולכים לראות זה את פונקציית continue with. פונקציית continue with באה ואומרת לנו אוקיי בואו תנו לי איזושהי פונקציה שאני הולכת לקרוא לה רק כאשר אני מסתיימת בתור T1. עכשיו אנחנו יכולים לראות שהפונקציה continue with אומרת לנו שהיא מקבלת action של task זאת אומרת היא
מקבלת action פונקציה שצריכה לקבל לסוגריים task, תכף אנחנו נראה מה אנחנו יכולים לעשות עם הtask הזאת. אם היינו נותנים את do work 2 בצורה כזאת אז אנחנו רואים שיש לנו פה בעיה כי דו-וורק 2 לא מתאימה לחתימה.
בואו נלך ונשנה את דו-וורק 2 כך שהיא תתאים לחתימה ותקבל task, ויהיה ה-task הקודמת. למה יש את השליחה הזאת או את הבקשה לפונקציה שמקבלת את ה-task הקודמת?
כי יכול להיות שהפונקציה שלנו צריכה משהו מה-task שכרגע התבצעה, לדוגמה את הערך המוחזר שלה. כרגע הערך המוחזר זה void, אז אין לנו מה לעשות איתו, אבל תכף נשנה את ה-void הזה ונראה איך זה פועל.
דבר נוסף, פונקציית ה-wait לא ממתינה לטאסק הקודמת, לכן מה שנעשה זה לטאסק הבאה בתור. אז מה שנעשה זה console.readline בכדי שתהיה לנו פה איזושהי המתנה ונוכל לראות את הכל עובד בצורה סינכרונית אחד אחרי השני.
אז בואו נראה איך זה מתבצע. אנחנו מריצים ואנחנו הולכים לראות שיש לנו כאן start work 1, do work 1 ואז end do work 1. רק לאחר מכן יש לנו פה start do work 2 ואז end do work 2. זאת אומרת הם לא התבצעו ביחד אלא רק כאשר הtask t1 הסתיימה אז בעצם היא הפעילה עוד task שביצעה את do work 2. אם הtask הראשונה הייתה גם מחזירה ערך פה נגדיר שאנחנו מחזירים
integer נלך ל do work 1 ונגדיר שהוא מחזיר לנו איזשהו מספר אנחנו יכולים להשתמש במספר הזה בתוך do work 2. נדפיס previous task result ויש לנו פה את ה-prev task נקודה result כמובן אנחנו צריכים להגדיר את התסק הזאת פעם כאינטג'ר ויש לנו פה את ה-result נריץ נראה שרק כשהתסק הראשונה מסתיימת אז התסק השנייה מתחילה ולא
רק זה שהיא מתחילה היא גם מקבלת את התוצאה שהתסק הקודמת החזירה והיא יכולה כמובן לבצע בשימוש כך אנחנו יכולים להגדיר סדרה של מטלות שרוצות האחת אחרי השנייה, אנחנו יכולים להמשיך ולעשות פה Continuid, Continuid, Continuid וכך לבצע סדרה של מטלות, בואו נעשה אפילו את DoWork 3 שהולכת לקבל את DoWork 2
או ליתר דיוק את ה-Task שהפעילה את DoWork 2, בואו נראה ש-Continuid מצפה לקבל שוב פעם Action של Task, נעשה פה אפילו איזושהי החזרה של איזשהו ערך, שעדיף לעזוב את זה אפילו ולהראות גם דוגמה של פונקציה שלא מחזירה ערך.
נשנה רק את השמות כאן, יש לנו פה do work 3. הפונקציה הקודמת לא מחזירה כלום, אז ניפטר מזה. נגדיר שאנחנו רוצים להדפיס do work 3 כאן, ויש לנו עכשיו מצב שבו ה-task t1 מפעילה את do work 1, רק כאשר היא מסתיימת היא מפעילה את do work 2, ורק כאשר זאת מסתיימת היא מפעילה את do work 3,
בואו נריץ את כל הסיפור הזה יש לנו פה את do work אחד התחילה הסתיימה do work 2 התחילה הסתיימה ואפילו קיבלה את הפרמטר שמוחזר מ-do work 1 ואז do work 3 התחילה והסתיימה רק אחרי ש-do work 2 הסתיימה לגמרי כאן אנחנו יכולים לשרשר טאסקים אם אנחנו רוצים כך שהם לא יהיו ביחד אלא כל אחת עושה מטלה כשהיא מסתיימת מוגדרת
מטלה אחרת הכל זה טאסקים הכל זה טרדים שנמצאים בטרד פול ויש לנו פה סדרת מטלות שיכולות להתבצע אחד אחרי השני, שאנחנו יכולים להגדיר אותם פעם אחת, להגדיר סטארט ואנחנו יודעים שכולם יתבצעו בצורה סינכרונית אחת אחרי השנייה.
הדבר הבא שאנחנו הולכים לראות שבנוי על ידי טאסקס זאת מחלקה מעניינת מאוד שנקראת פארלל. פארלל מאפשרת לנו לבצע כביכול לולאות או סדרת פעולות שמשתמשת בתוך עצמה ב-Tasking.
בואו נפתח פה פרויקט Parallel Example ומה שאני רוצה לעשות עכשיו זו פעולה מאוד מאוד פשוטה, אני רוצה לקחת לולאה שרצה 10 פעמים, מבצעת הדפסה של המספר I, בוא נניח באותה שורה, ומבצעת איזושהי המתנה Thread.Slip של חצי שנייה ועכשיו אם אנחנו נריץ את זה אנחנו אנחנו הולכים לראות שבעצם מוצגים לנו כל
המספרים מ-0 עד 9 אבל המספרים האלה כמובן מוצגים בלולאה שלוקחת זמן בצורה סינכרונית אחד אחרי השני ולפי הסדר כי כל הפעילות הזאת לא התבצעה ביחד, לא התבצעה במקביל.
אוקיי, מה קורה אם אני עדיין רוצה לבצע הדפסה של כל המספרים מ-0 עד 9 אבל לא אכפת לי הסדר או ליתר דיוק אם אתם רוצים לקחת סדרת מטלות לקחת לולאה שתבצע את כל המטלות האלה בוא נניח 100 דברים שונים שאתם רוצים לבצע אבל לא ממש אכפת לכם שכל הדברים האלה יתבצעו אחד אחרי השני לפי הסדר אם אתם רוצים שכל הדברים האלה יהיו במקביל אז כמובן כדאי
לנו לפתוח טסקים בשביל לבצע את זה לדוגמה יכול להיות שליחת המון מיילים ביחד למה אני צריך ללכת ולשלוח מייל ולהמתין שהוא ישלח ואז ישלוח עוד מייל אין קשר ביניהם אני רוצה לשלוח בבת אחת 100 מיילים או 1000 מיילים לכל רשימת התפוצה שלי או להדפיס מספר הדפסות בבת אחת או לבצע מספר חישובים שלא קשורים אחד לשני או לגשת לדאטאבייס למאגר נתונים ולהביא המון המון נתונים ביחד שלא קשורים אחד לשני.
אז כל פעם שאנחנו רוצים לבצע את כל הדברים האלה במקביל ויש לנו סדרת דברים שאנחנו רוצים לבצע ואנחנו רוצים לולאה במקום לקחת לולאת for רגילה בואו נשים אותה פה בהערה אנחנו יכולים להשתמש עם המחלקה parallel.
המחלקה Parallel קיימת שוב פעם ב-System Threading Tasks והיא פותחת בתוך עצמה טאסקים בשביל להוציא לפועל את הפעילות שלנו.
לדוגמה, Parallel 4. Parallel 4 אומרת לנו, תביאו לי את האינדקס ההתחלתי. בדיוק כאילו אנחנו לולת 4 רגילה. בלולת 4 רגילה האינדקס ההתחלתי שלנו היה 0. אוקיי, אז בואו נביא לה 0.
לאחר מכן היא אומרת לנו, תביאו לי את האינדקס הסופי,