خوش برگشتید.
خب، در این ویدیو می‌خواهم در مورد چیزی صحبت کنم که کمی بیشتر به هسته‌ی **C#** مربوط می‌شود، یعنی اینکه **C#** چگونه با چیزهایی که
ساخته و حذف می‌شوند، برخورد می‌کند.
منظورم چیست؟
خب، می‌دانید که ما همیشه چیزهای جدیدی ایجاد می‌کردیم، مثل **struct**های جدیدی که قبلاً داشتیم و
اینکه چطور می‌توانیم **متغیرهای موقت** را که خارج از **scope** (حوزه) خود هستند، حذف، پاک و حتی ایجاد کنیم.
و به همین سادگی حذف خواهند شد.
درسته.
پس چه اتفاقی برای این‌ها می‌افتد؟
خوشبختانه، **C#** یک زبان است که تقریباً همه چیز را خودش و بدون دخالت ما مدیریت می‌کند.
اما بیایید کمی درباره نحوه انجام این کار بدانیم.
خیلی خب، پس شروع کنیم.
بنابراین، **Garbage Collection** (جمع‌آوری زباله) ابزاری است که در چندین زبان برنامه‌نویسی در دسترس است.
و در بعضی از آنها به صورت دستی انجام می‌شود و در برخی دیگر به صورت خودکار.
و **دات**.
**نت فریم‌ورک** یک **مدیریت حافظه خودکار** را فراهم می‌کند، به این معنی که شما مجبور نیستید از **Garbage Collector**
به صورت دستی استفاده کنید، همانطور که در سایر زبان‌های برنامه‌نویسی انجام می‌دهید.
بنابراین، زبان‌های برنامه‌نویسی مانند **C** یا **C++** و سایرین، **Garbage Collection** دستی دارند
که باید هر از گاهی آن را اجرا کنید و باید بدانید چه زمانی باید آن را اجرا کنید.
بنابراین این کاری است که در **C#** به طور خودکار انجام می‌شود.
به همین دلیل است که چیزی نیست که، خب، بسیاری از مردم خیلی اوقات از آن استفاده کنند.
بنابراین، وقتی برنامه‌های پیچیده‌تری دارید و واقعاً حرفه‌ای هستید، هر از گاهی شروع به استفاده از آن خواهید کرد.
هر از گاهی.
اما واقعاً چیزی نیست که مجبور باشید همیشه از آن استفاده کنید، یا حتی در
بیشتر موارد مجبور به استفاده باشید.
به همین دلیل است که موضوع اصلی محسوب نمی‌شود.
خیلی خب.
بنابراین فرض کنید این **آبجکت** به نام **Dennis** را داریم و از **نوع human** است.
پس من یک **کلاس** به نام **human** ایجاد کردم.
و چندین **property** (ویژگی) مختلف و غیره وجود دارد.
پس در نهایت من فقط یک **آبجکت از نوع human** ایجاد می‌کنم.
و نام آن **Dennis** است.
و با انجام این کار، با استفاده از این **کلمه کلیدی new**، به **حافظه** نیاز دارم چون یک **آبجکت** در **حافظه** من ایجاد می‌کند.
بنابراین **C#** برای ما **حافظه** تخصیص می‌دهد و **فریم‌ورک** مراقبت می‌کند که **حافظه** را برای استفاده مجدد در
**سیستم** بازپس گیرد، زمانی که **آبجکت‌ها** دیگر استفاده نمی‌شوند.
بنابراین در این حالت من این **آبجکت** را ایجاد می‌کنم.
و بعد ممکن است از آن استفاده کنم و بارها و بارها از آن استفاده کنم.
اما در یک نقطه دیگر از آن استفاده نخواهم کرد و شاید حتی **reference** (ارجاعات) به آن را قطع کنم.
و بعد، خب، **Garbage Collector** آن را پاک خواهد کرد زیرا این **حافظه** حالا مسدود شده است و **Garbage Collector** باید آن را پاک کند.
بنابراین باید این **حافظه** را دوباره برای سایر **آبجکت‌ها** در دسترس قرار دهد.
به عنوان مثال.
حالا بیایید از منظر بصری به آن نگاه کن > NESA: یم.
بنابراین ما این **memory pool** (بخش حافظه) **سیستم** را در سمت چپ و برنامه خود را در سمت راست داریم.
و **memory pool سیستم** کلی **حافظه** دارد.
پس می‌توانیم از این **حافظه** برای برنامه‌های مختلف استفاده کنیم.
اما حالا برنامه خودمان را داریم که در حال اجراست.
و حالا در برنامه خود یک **آبجکت** ایجاد می‌کنیم.
حالا ناگهان به کمی فضا در **حافظه** نیاز داریم.
خیلی خب.
بنابراین یک **reference** (ارجاع) از برنامه ما به آن **حافظه** که **آبجکت** ما در آن ذخیره شده، وجود دارد.
خیلی خب.
پس یک **reference** مستقیم وجود دارد و ما می‌توانیم دوباره از آن استفاده کنیم و آن را از نقاط مختلف فراخوانی کنیم و غیره.
خیلی خب.
و بعد یکی دیگر داریم و یکی دیگر.
بنابراین **آبجکت‌های** مختلفی داریم که ایجاد کردیم.
و هر بار که یک **آبجکت** جدید ایجاد می‌کنیم، یک **حافظه** در **memory pool** تخصیص داده می‌شود.
و یک **reference** از برنامه ما به آن **حافظه** وجود دارد.
بنابراین این **reference**ها آنجا هستند.
پس یک **reference** از برنامه ما به **memory pool** وجود دارد.
حالا در یک نقطه ممکن است **reference** حذف شود.
پس ممکن است **reference** را با تنظیم یک **variable null** یا با تنظیم **آبجکت** به **null** حذف کنیم.
و بعد **reference** ناگهان از بین می‌رود.
حالا دیگر هیچ **reference**ای از برنامه ما به این تخصیص **حافظه** کوچک اینجا وجود ندارد.
بنابراین **Garbage Collector** ما متوجه می‌شود و می‌بیند، خب، **reference**ای وجود ندارد.
پس این تکه کوچک **حافظه** هرگز استفاده نمی‌شود.
بنابراین بیایید فقط آن را پاک کنیم یا دوباره آن را تخصیص دهیم یا فقط آن را برای تخصیص‌های دیگر آزاد کنیم.
و این همان چیزی است که بعداً اتفاق می‌افتد.
بنابراین حالا بیایید به مثالی نگاه کنیم که چه زمانی **Garbage Collector** وارد عمل می‌شود.
و من یک **function** (تابع) اینجا دارم به نام **my function**.
و من دوباره یک **آبجکت** اینجا ایجاد می‌کنم که نامش **Dennis** است.
و بعد **Dennis** متدهای خودش را فراخوانی می‌کند یا ما متدهای او را فراخوانی می‌کنیم، مانند **teach** (آموزش).
بعد سن او را تنظیم می‌کنیم و بعد متد دیگری به نام **get older** (پیرتر شدن) و غیره را فراخوانی می‌کنیم.
اما در یک نقطه دیگر این **آبجکت Dennis** در **حافظه** مورد نیاز نیست زیرا فراخوانی **function**
تمام شده است.
بنابراین **function** تمام می‌شود، **آبجکت Dennis** از **scope** خارج می‌شود و دیگر هیچ **reference**ای به **Dennis** وجود ندارد،
زیرا **my function** یک **function** است و ما این **آبجکت** را داریم که درون یک **function** است، بنابراین **scope** (حوزه)
آن درون **function** است.
بنابراین هنگامی که فراخوانی **function** تمام می‌شود، دیگر **reference** مستقیمی به آن وجود ندارد زیرا نمی‌توانیم به
**آبجکتی** که درون یک **function** است، از خارج از این **function** **reference** کنیم.
درسته.
بنابراین برای این کار باید **field** (فیلد) ایجاد کنیم یا رویکردهای دیگری را انجام دهیم.
اما در نهایت **Garbage Collector** فقط این **Dennis** را پاک می‌کند و این **حافظه** را دوباره تخصیص می‌دهد.
و ایده کلی در اینجا واقعاً این است که این فقط یک مثال ساده است.
سناریوهای زیادی وجود دارد که **Garbage Collector** وارد عمل می‌شود، اما این چیزی است 85 > NESA:
که ما قبلاً از آن استفاده کرده‌ایم.
بنابراین مفاهیمی که در اینجا می‌بینید، ما قبلاً آنها را در ویدیوها یا درس‌های دیگر این دوره
دیده‌ایم.
به همین دلیل این مثال را انتخاب کردم.
پس چه چیزی باید در مورد **Garbage Collection** بدانید؟
خب، شما مجبور نیستید **Garbage Collector** را به صورت دستی فراخوانی کنید، اما می‌توانید این کار را به صورت دستی انجام دهید.
**Garbage Collector** به **processing power** (قدرت پردازش) نیاز دارد، بنابراین در یک **thread** جداگانه است و بسیار سبک است،
اما باز هم مقداری **processing power** مورد نیاز است.
هدف **Garbage Collector** آزاد کردن **حافظه** است، اما نه استفاده بیش از حد از **processing power**.
بنابراین به طور کلی به **processing power** زیادی نیاز نخواهد داشت.
اما همیشه فراخوانی نخواهد شد.
یا **Garbage Collector** همیشه برای آزاد کردن **حافظه** اجرا نخواهد شد.
فقط زمانی اجرا می‌شود که ضروری باشد یا زمانی که آن را ضروری بداند، زمانی که فکر می‌کند ضروری است.
بنابراین این واقعاً بخش مشکل اینجاست.
**حافظه** لزوماً بلافاصله بازپس گرفته نمی‌شود.
ممکن است کمی طول بکشد.
یا **Garbage Collector**، حتی اگر آن را به صورت دستی فراخوانی کنید، مجبور نیست بلافاصله اجرا شود.
بنابراین اینها برخی از نکات ظریف در مورد **Garbage Collector** هستند.
شما می‌توانید **method Finalizer** را برای اجرای **کد** درست قبل از اینکه یک **آبجکت** توسط **Garbage Collector** از **حافظه** آزاد شود، پیاده‌سازی کنید.
توسط **Garbage Collector**.
این به این معنی است که اگر تصمیم بگیرید یک **کد** خاص را درست قبل از پاک شدن یک **آبجکت** اجرا کنید، یعنی درست قبل از اینکه
**Garbage Collector** آن را پاک کند.
بنابراین هنگامی که دیگر هیچ **reference**ای به آن وجود ندارد، به عنوان مثال، می‌توانید از **method Finalizer**
درون این **کلاس** برای پیاده‌سازی یک **functionality** (عملکرد) خاص که می‌خواهید اجرا شود، استفاده کنید.
شاید بخواهید خودتان چیزهایی را پاک کنید درست قبل از اینکه **Garbage Collector** بیاید و **آبجکت** شما را پاک کند،
یا **حافظه** را جابجا کند یا آن را آزاد کند.
این **آبجکت** از **حافظه**.
خیلی خب.
**Garbage Collector** چه زمانی اجرا می‌شود؟
خب، زمانی که **سیستم** **حافظه فیزیکی** کمی دارد.
زمانی که **حافظه تخصیص داده شده** از یک **آستانه** از پیش تعیین شده فراتر رود.
زمانی که **method** **garbage collector collect** یا **Gc.collect** فراخوانی شود.
حتی اگر این یک **method** فوق العاده پیچیده است.
بنابراین این چیزی است که خب، بسیار خاص و ویژه است.
اگر می‌خواهید در مورد آن بیشتر بدانید، باید مستندات مربوط به **Garbage Collector** را بررسی کنید.
اما **method collect** همیشه بلافاصله فراخوانی نمی‌شود و همه چیز را مستقیماً پاک نمی‌کند.
بیشتر شبیه این است که شما دارید به ابزار یک پیشنهاد می‌دهید.
پس می‌گویید، خب، **Garbage Collector**.
من شخصاً فکر می‌کنم این یک نقطه خوب برای جمع‌آوری **Garbage** خواهد بود، اما در برخی موارد
ممکن است آن را قبول نکند، یا ممکن است آن را بعداً انجام دهد یا چیزی شبیه به آن.
شاید او به تازگی **Garbage Collection** انجام داده و تصمیم می‌گیرد که ضروری نیست یا چیزی شبیه به آن.
بنابراین این یک مورد بسیار پیچیده است. 127 0 > NESA:
اگر می‌دانید و می‌خواهید بیشتر در مورد آن بدانید، مستندات را بررسی کنید.
اما من فکر می‌کنم این یک نقطه شروع خوب برای درک این است که **Garbage Collector** چه کاری انجام می‌دهد.
و همانطور که گفتم، در بیشتر موارد به آن نیاز نخواهید داشت زیرا امروزه **حافظه** زیادی داریم.
و اگر **memory leak** (نشت حافظه) بزرگی در برنامه‌های خود نداشته باشید، هرگز نباید با این مشکلات روبرو شوید.
باشه، پس امیدوارم درک این موضوع آسان بوده باشد.
خوشبختانه، همانطور که گفتم، نباید نگران **مدیریت حافظه** باشید زیرا **C#** قبلاً آن را مدیریت می‌کند،
اما همچنین خوب است بدانید که چگونه آن را مدیریت می‌کند.
پس، خب، این برای این ویدیو کافی است.
شما را در ویدیوی بعدی می‌بینم.