Generics - חלק 3
List<Product>, ומממשים את הממשקים הגנריים של המוצר כדי להימנע מקאסטים.List<Product>. הפונקציה Add מקבלת מוצר בלבד, וכל פעולות הרשימה זמינות בלי קוד נוסף. מוסיפים רק את הפעולות הלוגיות של האוסף.List<T> יחד עם ממשקים גנריים נותנת אוסף מדויק, נקי וקל לתחזוקה.פרקי ההרצאה: Generics - חלק 3
תמלול ההרצאה: Generics - חלק 3
הטקסט המלא של הדקות הראשונות בהרצאה «Generics - חלק 3» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אז בואו נעשה אבל כרגע ראפר לליסט או ליתר דיוק זה לא יהיה ראפר זה יהיה משהו הרבה יותר פשוט. אז בואו נניח שאנחנו רוצים לבצע איזשהו קולקשן עבור פרודקס עבור מוצרים ולצורך כך נשתמש בכלים שכבר בנינו באחד הסרטונים הקודמים בסרטון הקודם בעסיקלי של קולקשנים לצורך כך בואו נצרף
אקזיסטינג אייטם. ונאתר את ה-collection שבנינו, בואו נלך לתיקיית ה-collections, ובנינו כאן איזשהו אוסף שמכיל את המחלקה product.
בואו ניגש, האמת שהיה לנו אחד אחר, ה-release trapper, זה היה יותר מתאים. היה לנו product ו-products וזה מה שאנחנו רוצים לבנות. בואו נסתכל על ה-product.
במחלקה הפשוטה ראינו שבנינו מחלקה שיש לה קוד, שם ומחיר. היא יורשת את iCompareable בכדי שניתן יהיה לבצע מיון איתה.
יש לה קונסטרקטור, two-string, equals, get-hash-code, compare-to. יש לנו פה כל מיני מחלקות שמאפשרות לבצע מיונים אחרים.
לדוגמה, product-price-comparer, בכדי לבצע מיון לפי מחיר. גם בסדר עולה, גם בסדר יורד. יש לנו פה את ה-enum שבנינו. ומה שעשינו במחלקה פרודקטס זה ירשנו או ליתר דיוק הכנסנו בתוך המחלקה את הרייליסט ואז מה שעשינו בעסיקלי זה בנינו ראפר להרייליסט.
זאת אומרת לא רצינו שהמחלקה פרודקטס מישהו יוכל להכניס אליה כל דבר, רצינו שהוא יכניס אליה רק מוצרים ולכן לקחנו את הרייליסט ומה שעשינו בתוך הרייליסט בתוך המחלקה שלנו זה בנינו שלושה דברים שמכילים בחתימה שלהם את המחלקה product.
פונקציית add שמאפשרת לקבל רק מוצר, פונקציית remove שמאפשרת לקבל רק מוצר ואופרטור סוגריים מרובעים שמאפשר לקבל אינדקס ולהחזיר מוצר.
כל היתר זה פונקציות שנבנו על גבי הרליסט. מה שאני רוצה להראות עכשיו זה שימוש בכל מיני כלים שכבר למדנו בכדי שיהיינו חיים יותר קלים.
בואו נניח שמחלקה פרודקט היא מוכנה והיא כבר מתאימה לנו, אבל כאשר אנחנו רוצים לבנות מחלקה שמכילה אוסף מוצרים, אנחנו לא צריכים לעשות יותר ראפר להראה ליסט.
כל מה שאנחנו צריכים לעשות זה לרשת את ליסט לדוגמה של פרודקט. וכעת גם אנחנו ליסט של פרודקט. זה אומר שגם לנו יש פונקציית add שיכולה לקבל אך ורק פרודקט.
אז בואו נסתכל מה אנחנו לא צריכים. אנחנו לא צריכים את ה-items ואנחנו לא צריכים את הקונסטרקטורים האלה. ואנחנו לא צריכים, למעשה אולי קונסטרקטור של capacity כן כדאי שיהיה לנו.
בואו כרגע ניפטר מזה שיהיה לנו חיים יותר קלים. לא צריכים count, לא צריכים capacity, כל הדברים האלה קיימים אצלנו בילד אין.
פונקציית add, remove, add, יש לנו אופרטור סוגריים מרובעים, יש לנו. שימו לב שאני פשוט מעיף את כל מה שקיים בי דיפולט, לא צריכים את הגט אינומרטור כי כבר יש לנו.
כל מה שאנחנו צריכים להוסיף זה רק את הפעילויות הלוגיות שקיימות במחלקה פרודקטס ואנחנו רוצים שהם יהיו חלק מאוסף המוצרים שלנו.
לדוגמה, בדוגמה שאנחנו עשינו עם הקולקשן הזה הייתה לנו פונקציה, או שבנינו פונקציה שנקראת גט אברנג' פרייס שהיא החזירה לנו את כל או ליתר דיוק את הממוצע של כל המוצרים שיש לנו באוסף.
אז אם הפונקציה הזאת היא ספציפית טובה עבור האוסף שלנו ואנחנו רוצים אותה בתוך מחלקת האוסף, אז כמובן שכדאי לנו לבנות אותה. אבל אנחנו לא יכולים לרוץ כבר על אייטמס כי אין לנו אייטמס, אנחנו רצים על דיס.
דיס זה בעצם אנחנו ואנחנו ירשנו את ליסט של פרודקט ולכן גם אנחנו ליסט של פרודקט ואנחנו מסוגלים לרוץ על עצמנו אז כעת אנחנו רואים שהרבה יותר קל לנו ללכת ולבנות מחלקת אוסף ואני מזכיר לכם כמעט תמיד כאשר אתם מתעסקים באיזשהו קולקשן בצורה רחבה בפרויקט שלכם כדאי לכם ללכת ולבנות מחלקה ייעודית עבור הקולקשן הזה אם הקולקשן הוא מה שנקרא flat collection כלומר מסדרת פריטים כמו
list או כמו מערך אז אנחנו תמיד נירשת ליסט ונוכל בצורה כזאת להוסיף עוד פריטים או עוד פונקציות שמתאימות לקולקשן שלנו. המקרה היחידי שבו אנחנו לא נירשת ליסט ואם אנחנו כן צריכים לרשת מישהו אחר.
אולי במקרה הזה אם זה מאוד מאוד חשוב לנו לרשת את המישהו האחר הזה והוא גם לא יורשת ליסט אז אולי אנחנו נגדיר את ליסט כמשתנה בתוך המחלקה שלנו כמו שהגדרנו את הריי ליסט ואז זה יהיה פחות או יותר ראפר מעל ליסט אבל בדרך כלל זה לא המצב בדרך כלל אנחנו נוכל לרשת את ליסט בכדי לבנות את האוסף שלנו ומעכשיו והלאה אנחנו גם ליסט.
זאת אומרת אם אני עכשיו פונה לפרוגרם בואו נשים את הפרודקטס ורטיקלית לידינו אם אני עכשיו פונה למחלקה פרוגרם למיין ויוצר אובייקט פרודקטס כמובן שאנחנו צריכים אמור על מרחבי שמות זהים בכדי שיהיה לנו קל לעבוד בצורה כזאת.
הנה products, myproducts שווה new products. כאשר אנחנו פונים ל-myproducts.ad קודם כל שימו לב שבכלל יש לנו פה את כל הפונקציות שקיימות בתוך ליסט.
אם אנחנו פונים ל-ad אנחנו רואים ש-ad אומרת לנו תביאו לנו מוצר אחד ויחיד. אל תביאו לנו person, אל תביאו לנו string, תביאו לנו רק מוצר. בואו נפתח אובייקט new product.
ונגדיר לו איזשהו קוד, נגדיר לו איזשהו שם, ונגדיר לו איזשהו מחיר. נוסיף עוד שניים כאלה, יש לנו פה סדרה של מחירים נוספים.
נגדיר פה כמובן את M, שמאפשר לנו להגדיר money. וכעת אנחנו יכולים לרוץ ב-foreach על כל הפריטים. בואו נריץ את זה, ונראה שהכל עובד כמו שצריך.
ויש לנו פה את שני היתרונות שדיברנו עליהם בעבר, במודול של ה-collections. יתרון ראשון, אנחנו יכולים להוסיף רק מוצרים ולא שום טיפוס נתונים אחר, ולא עשינו הרבה לצורך כך, כל מה שעשינו זה ירשנו את list של product.
והיתרון השני, שהוא לא פחות חשוב, שעכשיו אנחנו יכולים להגיע לפעילויות ספציפיות שאנחנו צריכים, לדוגמה, get average price.
בואו נריץ, ונראה שהאברג' פרייס זה 2.7666 והפעילות הזאת קיימת כחלק מהמחלקה שלנו ותאמינו או לא בדרך כלל כשיש לכם אוסף מרכזי פתאום מתחילים להתווסף לכם הרבה הרבה הרבה הרבה פונקציות ופעילויות ומשתנים שאתם צריכים כחלק מהאוסף שלכם כי פתאום אתם מגלים שבמהלך התוכנית אתם צריכים לעשות
המון דברים שונים עם האוסף הזה. אז כאן אנחנו רואים ששילבנו יכולות שונות שראינו גם את היכולת של להשתמש בליסט של פרודקט וגם את היכולת של הורשה מליסט, בניית מחלקה משלנו והוספת דברים ואנחנו נהנים פה מכל העולמות בהקשר הזה.
הדבר הבא שחשוב שנכיר בעולם הג'נריק זה גם כן תשתית ג'נריק שקיימת בדוטנט והתשתית הזאת מדברת על אינטרפייסים של ג'נריק. ראינו שכאשר אנחנו עבדנו עם המחלקה Product לדוגמה, אז מה שעשינו זה ירשנו מספר אינטרפייסים, לדוגמה ירשנו את iCompareable וירשנו את iCompare פה במחלקה שבנינו ומימשנו אותם לצורך היכולת
לבצע מיון וחיפוש וכולי. אבל אם אנחנו מסתכלים על iCompareable לדוגמה אנחנו רואים שהפונקציה שלו Compare to מקבלת Object פה אנחנו חוזרים לעבוד עם Object אז מה הקונספט של הג'נריק?
אז כדאי מאוד להכיר גם את האינטרפייסים הנפוצים שנבנו כתשתית ב-dotnet ואם יש לנו אפשרות להשתמש איתם עדיף לנו להשתמש איתם מאשר להשתמש עם אינטרפייסים שהם לא ג'נריקס בדיוק כמו שהיה עדיף לנו להשתמש עם ליסט מאשר עם הריי ליסט.
אז כל מה שאני רוצה לעשות זה לבצע שינוי על פרודקט בכדי להשתמש באינטרפייסים האלה. אז לצורך הדוגמה בואו נשים את פרודקט פה ורטיקלי כדי שנוכל לעבוד איתו ותוך כדי זה שיהיה לנו את המיין לידינו.
אז כמו שיש לנו Icomparable יש לנו גם Icomparable Generics וכל מה שאנחנו רוצים לעשות זה להשוות בין פרודקט אחד לפרודקט שני ולכן זה האינטרפייס שאנחנו צריכים לבנות.
אז אני כרגע אלחץ control צדיק סופית או control נקודה, אתם יכולים לקרוא לזה implement interface i comparable של product ובואו נסתכל פה למטה נראה שהתווספה לנו פונקציה גם היא נקראת compare to אבל היא לא מקבלת object היא מקבלת product.
בואו ניקח את הפונקציה הזאת ונחליף איתה את הפונקציה הקודמת נשים אותה קודם כל כאן נסתכל על הפונקציה הקודמת הפונקציה הקודמת שבנינו פעם של iCompatible קיבלה Object וכל מה שהיא עשתה זה השוותה בין ה-Name הנוכחי ל-Name של האובייקט שהתקבל
אבל לצורך כך היינו צריכים לבצע קאסטינג זה אחד מהחסרונות של Object.