Generics - חלק 4
IEnumerable<ConsoleColor>. בלי הירושה foreach לא תרוץ על המחלקה.IEnumerator<ConsoleColor>, ולכן אין צורך בקאסט.IEnumerable<ConsoleColor> בלי לכתוב מחלקת אינומרטור. בשיעור מוצגת פונקציה כזאת שמחזירה את צבעי הקשת, ו-foreach רצה עליה עם טיפוס מוגדר.פרקי ההרצאה: Generics - חלק 4
תמלול ההרצאה: Generics - חלק 4
הטקסט המלא של הדקות הראשונות בהרצאה «Generics - חלק 4» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שני האינטרפייסים הבאים שדי חשוב לנו להכיר אותם בכדי להיות ממש מקצוענים בתחום זה ה-I-Enumerator וה-I-Enumerable שראינו בעבר כשלמדנו על קולקשנים ובואו נראה איך אנחנו משתמשים עם הגרסת הג'נריק שלהם וגם שקיים פה עוד משהו מעניין בנוגע לאינטרפייסים שלא ראינו מעולם וכדאי להבין שהוא קיים בפיתוח ואיך אנחנו מתמודדים איתו.
אז קודם כל בואו נבנה פה פרויקט חדש, נקרא לו Generic I Enumerable and I Enumerator והצמד שתמיד באים ביחד. ולצורך הדוגמה ניקח בדיוק את אותה הדוגמה שעשינו בסרטון על הקולקשנים, ואנחנו כתבנו בעבר איזושהי מחלקה שמהווה קשת בענן, ויש לה מספר צבעים ולכן אפשר להתייחס אליה
כאילו היא קולקשן של צבעים. אז במקום לכתוב אותה מחדש בואו נאתר את הגרסת הקולקשן שלא הייתה עם ג'נריק. הנה אנחנו רואים פה את התרגילים עם הקולקשן והתרגיל הזה היה טסט אינומרבל אם אני לא טועה.
בואו נראה אם יש לנו פה את זה. הנה הריינבו שבנינו. בואו נראה מה יש בתוך המחלקה. המחלקה עצמה נקראת ריינבו כלומר קשת ויש לה מספר צבעים חמישה צבעים.
יש לה את הצבעים עצמם מסוג קונסול קולור. אדום, צהוב, ירוק, כחול וסגול וירשנו את איי נומראבל בכדי שהיא תוגדר כקולקשן ולאחר מכן מימשנו את הפונקציה איי גטי נומרטור שהחזירה לנו אובייקט שיורש את איי נומרטור כאן היינו צריכים לבנות מחלקה נפרדת בנינו אותה כאינר קלאס שיורשת את איי נומרטור ומהווה בעצם איזשהו אובייקט שמסוגל לרוץ על האוסף תלולה תפורית שהייתה משתמשת עם הפונקציה הזו, עם
המחלקה הזאת, בכדי א' לגשת ולבצע moveNext ולהגיע כל פעם לפריט הבא על ידי קידום איזשהו פוזיישן. פונקציית moveNext מחזירה true במידה ויש מידע לקחת ו-current לוקחת את המידע לפי הפוזיישן.
כאן החזרנו את הפריט שהוא צבע לפי הפוזיישן וככה בעצם הצלחנו לרוץ על האוסף, או ליתר דיוק להחזיר אובייקט שפוריץ' השתמשה איתו בשביל לרוץ על האוסף הזה. אוקיי, אז אנחנו רוצים עכשיו לראות את גרסת הג'נריקס של כל הסיפור הזה, ולצורך כך קודם כל כדאי לנו לבנות את הריינבוו
אינומרטור בגרסת הג'נריק. גרסת הג'נריק אומרת אנחנו לא יורשים את i-אינומרטור אלא אנחנו יורשים את i-אינומרטור שמחזיר או שמייצג קונסול קולור, מפני שזה בעצם הפריט של האוסף, כל אחד מפריטי האוסף.
בגלל שאנחנו לא מבצעים דריסה או מימוש של i-נומרטור, אלא של מחלקה אחרת, ויש לה הרבה דברים דומים, מה שאני אעשה, כל מה שהגיע מ-i-נומרטור אני אשים רגע בהערה, כדי שהוא לא יתנגש לנו עם המחלקה החדשה שאנחנו יוצרים.
אבל לפני שאני אלחץ קונטרול נקודה בכדי לממש את האינטרפייס הזה, אני רוצה לעשות משהו מעניין. מה שאני רוצה לעשות, אני רוצה להגיע ל-definition, go to definition, שזה בעצם F12, ולראות את המחלקה הספציפית הזאת, או יותר דיוק זה לא מחלקה, זה אינטרפייס,
את האינטרפייס הזה. אז בואו ניגש אליו ונראה שבנו אותו כ-i-אינומרטור והוא מקבל t, אחלה, the interface.
אבל שימו לב שהוא יורש את i-disposable שזה איזשהו אינטרפייס שאנחנו ניגע בו בהמשך ולכן אנחנו צריכים שיהיה לנו גם את הפונקציות של i-disposable והוא יורש גם את i-אינומרטור והאינטרפייס i-אינומרטור שמקבל t של הג'נריק מקבל בייסיק או מכיל בייסיקלי t של קורנט ופה פתאום אנחנו רואים שיש פה איזה משהו מעניין קודם כל פעם ראשונה אנחנו רואים אולי פעם ראשונה
אנחנו רואים שאינטרפייס יכול לרשת אינטרפייס אחר אחלה אבל אם אינטרפייס ירש אינטרפייס אחר ואנחנו הולכים לממש את האינטרפייס הזה האם אנחנו צריכים גם לממש את האינטרפייסים שהם הבסיס והיא כן אנחנו צריכים לממש את כל מה שהגיע גם מאינטרפייס הבסיס כי אחרת למה האינטרפייס ירש אותם הוא ירש אותם בכדי לקבל מהם את הפונקציות שלהם ולכן אנחנו עכשיו מכילים באינטרפייס
שלנו גם את הקורנט הזה שמחזיר בעצם את אותו טיפוס ג'נרי שלנו וגם את מה שיש בבסיס ופה אנחנו נתקלים באיזושהי בעיה, למה לנו להתעסק עם הבסיסים האלה אם אנחנו לא באמת צריכים אותם?
אז אנחנו לא לא צריכים אותם, אנחנו לא צריכים חלק מהם. בואו נסתכל מה הכוונה. מה הגיע מאינטרפייס הבסיס I-נומרטור?
אם אנחנו מסתכלים על המימוש הקודם של I-נומרטור, מה שהגיע ממנו זה reset וזה move next וזה הקורנט, אבל קורנט החזיר אובג'קט.
אם אנחנו מסתכלים על i-נומרטור הנוכחי, אנחנו רואים שהוסיפו בו קורנט שמחזיר את אותו טיפוס שאנחנו מגדירים ב-i-נומרטור. זאת אומרת שעכשיו יש לנו שני קורנט, אחד שמחזיר אובג'קט ואחד שמחזיר את אותו טיפוס שאנחנו מגדירים כאן.
בנוסף, יש לנו פה את i-disposable שיש בו איזושהי פונקציה אחת dispose שאנחנו נאלצים לממש אותה גם אם אין לנו צורך בה אז נשאיר אותה ריקה.
אז בייסיקלי אנחנו רואים שכאשר אנחנו מממשים את i-נומרטור אנחנו צריכים לממש גם את i-נומרטור הבסיסי שמחזיר קורנט של אובייקט וגם את i-disposable וגם את כל מה שיש לנו פה קורנט שמחזיר.
בואו נראה איך זה מתבצע אם עכשיו אנחנו נלחץ על קונטרול נקודה ואנטר אנחנו נראה פה למטה שדוטנט כותבת לנו האדיטור כותב לנו את כל מה שאנחנו צריכים לממש הנה הריסט הנה המוב נקסט הנה דיספוז שהגיע מ-i-disposable הנה קורנט שמחזיר אובייקט ושהגיע מ-i-נומרטור הבסיס
והנה קורנט שמחזיר קונסול קולור כי זה ה-t שהגדרנו והוא והגיע מ-i-נומרטור של t הג'נריק. אבל פתאום אנחנו רואים משהו מאוד מעניין שקרה כאן.
אנחנו רואים שה-current שמחזיר את קונסול color והגיע מ-i-נומרטור הנוכחי שאנחנו מממשים הוא public, וה-current שמחזיר אובייקט והגיע מהבסיס הוא לא public, והוא בעצם נכתב בצורה כזאת של i-numerator.current.
וזה מתבצע לביצוע הדבר הבא. היידינג זה לצורך החבאה של קורנט זהה לקורנט הנוכחי שהגיע מהבסיס. אז בואו נרשום היידינג דה בייס קורנט פרופרטי.
אז בואו נסתכל איך אנחנו בעצם מסתירים פונקציה שהגיעה מאינטרפייס בסיס שהאינטרפייס שלנו ירש אותו.
אבל אני טיפה מקדים את זמני בואו נכתוב את זה לפי הסדר. ניקח את ריסט נעלה אותה פה למעלה נדביק אותה פה ואנחנו רוצים לממש את ריסט בדיוק באותו האופן.
זאת אומרת שאנחנו רוצים לשים 0 בתוך הפוזישן. כעת אנחנו יכולים להיפטר מהריסט הזאת. בואו ניקח את המוב נקסט והדבר הבא שאנחנו צריכים לממש.
נעלה אותה פה למעלה, נשים אותו ליד המוב נקסט זה ונממש אותו בדיוק באותו האופן כי המימוש הקודם בהחלט מתאים לנו. אנחנו צריכים לקדם את הפוזישן אחד קדימה ולהחזיר true אם הוא קטן או שווה ל-total colors.
זאת אומרת שאנחנו יכולים להיפטר מה-move next הזה. נחזור, ניקח את dispose, אין לנו צורך לממש את dispose, בהמשך אנחנו נבין מה זה dispose ומה עושים עם dispose, יהיה לנו ממש סרטון מיוחד לזה.
נשים אותה פה בסוף למטה, כי היא לא ממש מעניינת אותנו כרגע, הפונקציה הזאת. ועכשיו נראה איך אנחנו מתמודדים עם הדבר הזה.
אז מה שאנחנו צריכים לעשות זה לממש אך ורק את ה-current שהגיע מהאינטרפייס הנוכחי שלנו. איך נעשה את זה? בואו ניקח את כל התוכן הזה, סוויץ', נדביק אותו פה, נוריד את כל ההערה הזאת, קונטרול K, קונטרול U מוריד לנו הערה, קונטרול K, קונטרול C שם לנו הערה.
ניפטר מהאובג'קט הזה, ועכשיו נשאר לנו רק להחביא את הקורנט, הפרופרטי קורנט שהגיע מהאינטרפייס הבסיס שהאינטרפייס הנוכחי שלנו ירש אותו.
וכל מה שאנחנו צריכים לעשות בכדי להיפטר מזה או להחביא אותו זה להחזיר את גרסת הקונסול קולור של הקורנט. וכך בעצם פעם ראשונה אנחנו רואים איך אינטרפייס א' יכול לרשת אינטרפייס בסיס ובשניהם יש את אותה פונקציה או אותו פרופרטי שפרופרטי בייסיקלי זה פונקציה
אבל הם מחזירים דברים אחרים או שהם בעלי חתימה אחרת וכך אנחנו יכולים להחביא את הבסיס ולממש משהו שהוא יותר מתאים לנו מבחינת החתימה.
ה-corent, הפרופרטי קורנט ששייך לבסיס לאיי נומרטור של הבסיס החזיר אובייקט אז אנחנו לא מגדירים אותו עם פאבליק ואנחנו מגדירים אותו בצורה של inumerator.current והוא קורא לזה לקורנט שהוא יותר מתאים לנו בעזרת קאסטינג והוא כן מוגדר כפאבליק בלי ה-inumerator.
ומחזיר מה שאנחנו רוצים להחזיר. אם כך סיימנו לממש את inumerator של ConsoleColor ואנחנו יכולים ללכת ולממש את ה-Enumerable של ConsoleColor.
ובואו נסתכל ונראה את אותו הסיפור שראינו לפני זה. ניגש, מכש ימני GoToDefinition או F12 ונראה שגם כאן יש את אותו הסיפור.
ה-Enumerable קיים בגרסת הג'נריק שלו, מכיל פונקציה שהיא בעלת אותו השם כמו ה-Base שלו, היא נקראת גט אינומרטור היא מחזירה איי אינומרבל של אותו התי שלנו אבל אנחנו רואים שהאינטרפייס איי אינומרבל ירש את איי אינומרבל הבסיס שעבדנו איתו בזמנו והוא גם כן הכיל איזושהי פונקציה
גט אינומרטור שהחזירה לנו את האיי אינומרטור מורכב צודקים אבל אנחנו יודעים לאט לאט איך להתמודד עם כל הסיפור הזה כל מה שאנחנו צריכים לעשות בואו נסתיר שנייה אחת את הפונקציה הזאת זה להגיע לכאן עם הסמן של המקלדת ללחוץ ctrl נקודה enter ולראות פה למטה את הפונקציות שיתווספו לנו בואו נעלה אותם למעלה שיהיה יותר נוח להסתכל על זה נגיע לפה ונראה ששוב פעם אותו
הטריק יתבצע יש לנו כאן משהו מוזר יש לנו את האינטרפייס i enumerable של t generic