C# Language
कचरा कलेक्टर .Net में

बड़ी वस्तु ढेर संघनन

डिफ़ॉल्ट रूप से लार्ज ऑब्जेक्ट हीप को क्लासिक ऑब्जेक्ट हीप के विपरीत कॉम्पैक्ट नहीं किया जाता है जिससे मेमोरी विखंडन हो सकता है और आगे, OutOfMemoryException s तक ले जा सकता है

.NET 4.5.1 से शुरू होकर बड़े ऑब्जेक्ट हीप (कचरा संग्रहण के साथ) को स्पष्ट रूप से कॉम्पैक्ट करने का विकल्प है:

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();   

बस किसी भी स्पष्ट कचरा संग्रह अनुरोध के रूप में (इसे अनुरोध कहा जाता है क्योंकि सीएलआर इसे संचालित करने के लिए मजबूर नहीं किया जाता है) देखभाल के साथ उपयोग करें और डिफ़ॉल्ट रूप से इसे से बचें अगर आप GC आँकड़ों को डी-कैलिब्रेट कर सकते हैं, तो इसका प्रदर्शन कम हो सकता है।

कमजोर संदर्भ

.NET में, GC उन वस्तुओं को आवंटित करता है जब उनके लिए कोई संदर्भ नहीं बचा है। इसलिए, जबकि एक वस्तु अभी भी कोड से पहुंच सकती है (इसका एक मजबूत संदर्भ है), जीसी इस ऑब्जेक्ट को आवंटित नहीं करेगा। यह एक समस्या बन सकती है यदि बहुत बड़ी वस्तुएं हैं।

एक कमजोर संदर्भ एक संदर्भ है, जो जीसी को ऑब्जेक्ट को एक्सेस करने की अनुमति देता है, जबकि ऑब्जेक्ट को एक्सेस करने की अनुमति देता है। कमजोर संदर्भ केवल समय की अनिश्चित राशि के दौरान मान्य होता है जब तक कि वस्तु को एकत्र नहीं किया जाता है जब कोई मजबूत संदर्भ मौजूद नहीं होता है। जब आप कमजोर संदर्भ का उपयोग करते हैं, तो एप्लिकेशन अभी भी ऑब्जेक्ट के लिए एक मजबूत संदर्भ प्राप्त कर सकता है, जो इसे एकत्र होने से रोकता है। तो कमजोर संदर्भ बड़ी वस्तुओं पर पकड़ बनाने के लिए उपयोगी हो सकते हैं जो कि प्रारंभिक करने के लिए महंगे हैं, लेकिन कचरा संग्रह के लिए उपलब्ध होना चाहिए यदि वे सक्रिय रूप से उपयोग में नहीं हैं।

सरल उपयोग:

WeakReference reference = new WeakReference(new object(), false);

GC.Collect();

object target = reference.Target;
if (target != null)
  DoSomething(target);

इसलिए कमजोर संदर्भों को बनाए रखने के लिए इस्तेमाल किया जा सकता है, उदाहरण के लिए, वस्तुओं का एक कैश। हालांकि, यह याद रखना महत्वपूर्ण है कि एक मजबूत संदर्भ को फिर से स्थापित करने से पहले कचरा उठाने वाले को हमेशा इस जोखिम का सामना करना पड़ेगा।

मेमोरी लीक से बचने के लिए कमजोर संदर्भ भी उपयोगी हैं। घटनाओं के साथ एक विशिष्ट उपयोग का मामला है।

मान लीजिए कि हमारे पास स्रोत पर एक घटना के लिए कुछ हैंडलर हैं:

Source.Event += new EventHandler(Handler)

यह कोड ईवेंट हैंडलर को पंजीकृत करता है और ईवेंट स्रोत से श्रवण ऑब्जेक्ट तक एक मजबूत संदर्भ बनाता है। यदि श्रोता की तुलना में स्रोत ऑब्जेक्ट का जीवनकाल लंबा होता है, और श्रोता को उस घटना की आवश्यकता नहीं होती है जब कोई अन्य संदर्भ न हो, तो सामान्य .NET ईवेंट का उपयोग करने से मेमोरी रिसाव होता है: स्रोत ऑब्जेक्ट श्रोता ऑब्जेक्ट को स्मृति में रखता है जो कचरा एकत्र किया जाना चाहिए।

इस स्थिति में, यह कमजोर इवेंट पैटर्न का उपयोग करने के लिए एक अच्छा विचार हो सकता है।

कुछ इस तरह:

public static class WeakEventManager
    {
    public static void SetHandler<S, TArgs>(
    Action<EventHandler<TArgs>> add,
    Action<EventHandler<TArgs>> remove,
    S subscriber,
    Action<S, TArgs> action)
    where TArgs : EventArgs
    where S : class
        {
            var subscrWeakRef = new WeakReference(subscriber);
            EventHandler<TArgs> handler = null;

            handler = (s, e) =>
            {
                var subscrStrongRef = subscrWeakRef.Target as S;
                if (subscrStrongRef != null)
                {
                    action(subscrStrongRef, e);
                }
                else
                {
                    remove(handler);
                    handler = null;
                }
            };

            add(handler);
        }
    }

और इस तरह से इस्तेमाल किया:

 EventSource s = new EventSource();
 Subscriber subscriber = new Subscriber();
 WeakEventManager.SetHandler<Subscriber, SomeEventArgs>(a => s.Event += a, r => s.Event -= r, subscriber, (s,e) => { s.HandleEvent(e); });

इस मामले में निश्चित रूप से हमारे पास कुछ प्रतिबंध हैं - घटना अवश्य होनी चाहिए

public event EventHandler<SomeEventArgs> Event;

जैसा कि MSDN बताता है:

• लंबे कमजोर संदर्भों का उपयोग केवल तब करें जब आवश्यक हो, अंतिम स्थिति के बाद वस्तु की स्थिति अप्रत्याशित है।
• छोटी वस्तुओं के कमजोर संदर्भों का उपयोग करने से बचें क्योंकि सूचक स्वयं उतना बड़ा या बड़ा हो सकता है।
• स्मृति प्रबंधन समस्याओं के एक स्वचालित समाधान के रूप में कमजोर संदर्भों का उपयोग करने से बचें। इसके बजाय, अपने आवेदन की वस्तुओं को संभालने के लिए एक प्रभावी कैशिंग नीति विकसित करें।