טוב אני אמשיך ל-garbage collector
של dot.net. אז לפי מה שקראתי עליו, הוא עובד כך: כאשר נגמר המקום ב-heap, ה-GC מוצא את כל האובייקטים הנחוצים. הוא עושה זאת על-ידי כך שראשית הוא מסמן את ה-roots כישיגים,כאשר roots הם משתנים (ומצביעים) שנמצאים על המחסנית, משתנים סטטיים וגלובליים (שנמצאים כמובן על ה-Data Segment וגם את זה חשוב לדעת בראיונות), מצביעים שנמצאים ברגיסטרים של המעבד וכו'. dot.net כל הזמן מחזיק את רשימת ה-roots. לאחר-מכן הוא מוצא את כל המשתנים הישיגים מה-roots, כלומר אם נסמן את המשתנים כצמתים בגרף ואת הקשר "A מצביע ל או משתמש ב B" כקשר שעבורו נוצרת קשת, אז בעזרת BFS או DFS אפשר למצוא את כל הצמתים הישיגים בגרף הנ"ל. כמובן שאם ה-GC מגיע לצומת שכל הצמתים הישיגים ממנו כבר נתגלו, הוא לא ממשיך את החיפוש במסלול שממשיך דרך הצומת הזה (זה מונע מעגלים ומשפר ביצועים). לאחר שה-GC מצא את כל הצמתים הישיגים, אז הוא מצא בעצם את כל האובייקטים הנחוצים. לכן הוא יודע מה הם האובייקטים הלא נחוצים (האובייקטים שיושבים על ה-heap ואינם נחוצים) והוא יכול לנקות אותם מה-heap (כלומר לשחרר זיכרון). לאחר הניקוי הזה, נוצרים ב-heap חורים וה-GC מסדר את האובייקטים (ששרדו) כך שהם ישבו רצוף על ה-heap. יותר בפירוט, הסידור הזה על ה-heap נעשה כך: ה-heap מחולק ל-3 "דורות": דור 0, דור 1 ודור 2. בהתחלה כל האובייקטים שייכים לדור 0. לאחר שה-heap מתמלא, כל האובייקטים ששרדו עוברים לדור 1. מעכשיו כל האובייקטים החדשים מתווספים לדור 0. אם שוב ה-heap מתמלא אז עכשיו כל האובייקטים מדור 0 ששרדו עוברים לדור 1 וכל האובייקטים מדור 1 ששרדו עוברים לדור 2(כמובן שמכיוון שיש רק 3 דורות, כל מה שהיה בדור 2 ושורד נשאר מעכשיו בדור 2). היתרון של גישת הדורות הנ"ל היא שאפשר להתיחס באופן שונה לאובייקטים שיושבים בדורות שונים. כלומר, מכיוון שה-GC של dot.net מניח שאם אובייקט כלשהו שרד עד כה אז הוא ימשיך לשרוד ואם האובייקט הוא חדש אז כנראה שהוא יחיה זמן קצר, הוא יכול לבדוק את האובייקטים בדור 0 לעתים קרובות יותר מהאובייקטים בדור 1 ודור 2 וע"י כך לשפר ביצועים (לא צריך לבדוק את כל האובייקטים כל פעם ואלה שכן נבדקים, יש סבירות גבוהה שצריך להעיף אותם ולכן הם לא נבדקים לשווא). כמובן שהיתרון של GC הוא שהוא פותר לגמרי את המתכנת מאחריות לניהול זיכרון ומאפשר לו להתעסק בדברים יותר חשובים (כלומר בלוגיקה של האפליקציה שהוא כותב). בנוסף לחיסכון בזמן, נחסכים גם באגים (שגם הטיפול בהם עולה בזמן) כמו dangling pointers ודליפות זיכרון. החיסרון הוא שה-GC עלול להיות פחות יעיל מניהול ידני של זיכרון, כי הוא לא מכיר את הלוגיקה של התכנית. כמו-כן, מכיוון שהוא זורק את הזבל רק כשיש הרבה זבל (די דומה לאיך שזורקים זבל בבית), הוא עלול לגרום לעצירות ממושכות יותר בתכנית למטרת ניקוי זבל, במקום עצירות קצרות שהיו נגרמות בגלל שחרור של אובייקט אחד בלבד על-ידי המתכנת.