क्या सीएलआर में कमजोर या कमजोर चयन (जैसे वीक रेफरेंस) करने का कोई तरीका है?

Question

List<WeakReference> का उपयोग कर काम नहीं करेगा जैसा मैं चाहता हूं। मैं चाहता हूं कि वीक रेफरेंस स्वचालित रूप से सूची से हटा दिया गया हो, जब भी वे ऑब्जेक्ट संदर्भित करते हैं तो कचरा एकत्र होता है।

ConditionalWeakTable<TKey,TValue> मुझे संतुष्ट नहीं करता है, क्योंकि यद्यपि इसकी चाबियाँ और मूल्यों को कमजोर संदर्भित और एकत्रित किया जा सकता है, आप उन्हें गणना नहीं कर सकते!

Answer 1

मैं मानता हूँ कि एक WeakList<T> को लागू करने के लिए संभव है, लेकिन मुझे नहीं लगता कि यह वास्तव में आसान है। मेरा कार्यान्वयन here का उपयोग करने के लिए आपका स्वागत है। WeakCollection<T> वर्ग WeakReference<T> पर निर्भर करता है, जो बदले में SafeGCHandle पर निर्भर करता है।

Answer 2

आप आसानी से WeakList<T> कक्षा लागू कर सकते हैं, जो List<WeakReference> को लपेट देगा।

कचरा इकट्ठा होने पर वस्तुओं को स्वचालित रूप से निकालने का कोई तरीका नहीं है, क्योंकि ऐसा होने पर यह पता लगाना संभव नहीं है। हालांकि, WeakReference.IsAlive संपत्ति की जांच करके, जब आप उन्हें सामना करते हैं तो आप "मृत" (कचरा एकत्रित) वस्तुओं को निकाल सकते हैं। हालांकि, मैं इस दृष्टिकोण की अनुशंसा नहीं करता, क्योंकि इससे ग्राहक के दृष्टिकोण से भ्रमित व्यवहार हो सकता है। इसके बजाय, मैं मृत प्रविष्टियों को हटाने के लिए Purge विधि को लागू करने की अनुशंसा करता हूं, जिसे आप स्पष्ट रूप से कॉल करेंगे।

WeakReference<T> (WeakReference चारों ओर सिर्फ एक दृढ़ता से टाइप किया आवरण)

[Serializable] 
public class WeakReference<T> : WeakReference 
{ 
    public WeakReference(T target) 
     : base(target) 
    { 
    } 

    public WeakReference(T target, bool trackResurrection) 
     : base(target, trackResurrection) 
    { 
    } 

    public WeakReference(SerializationInfo info, StreamingContext context) 
     : base(info, context) 
    { 
    } 

    public new T Target 
    { 
     get 
     { 
      return (T)base.Target; 
     } 
    } 
} 

:

public class WeakList<T> : IList<T> 
{ 
    private List<WeakReference<T>> _innerList = new List<WeakReference<T>>(); 

    #region IList<T> Members 

    public int IndexOf(T item) 
    { 
     return _innerList.Select(wr => wr.Target).IndexOf(item); 
    } 

    public void Insert(int index, T item) 
    { 
     _innerList.Insert(index, new WeakReference<T>(item)); 
    } 

    public void RemoveAt(int index) 
    { 
     _innerList.RemoveAt(index); 
    } 

    public T this[int index] 
    { 
     get 
     { 
      return _innerList[index].Target; 
     } 
     set 
     { 
      _innerList[index] = new WeakReference<T>(value); 
     } 
    } 

    #endregion 

    #region ICollection<T> Members 

    public void Add(T item) 
    { 
     _innerList.Add(new WeakReference<T>(item)); 
    } 

    public void Clear() 
    { 
     _innerList.Clear(); 
    } 

    public bool Contains(T item) 
    { 
     return _innerList.Any(wr => object.Equals(wr.Target, item)); 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     _innerList.Select(wr => wr.Target).CopyTo(array, arrayIndex); 
    } 

    public int Count 
    { 
     get { return _innerList.Count; } 
    } 

    public bool IsReadOnly 
    { 
     get { return false; } 
    } 

    public bool Remove(T item) 
    { 
     int index = IndexOf(item); 
     if (index > -1) 
     { 
      RemoveAt(index); 
      return true; 
     } 
     return false; 
    } 

    #endregion 

    #region IEnumerable<T> Members 

    public IEnumerator<T> GetEnumerator() 
    { 
     return _innerList.Select(x => x.Target).GetEnumerator(); 
    } 

    #endregion 

    #region IEnumerable Members 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return this.GetEnumerator(); 
    } 

    #endregion 

    public void Purge() 
    { 
     _innerList.RemoveAll(wr => !wr.IsAlive); 
    } 
} 

इस वर्ग के निम्नलिखित वर्गों और विस्तार तरीकों का उपयोग करता:

यहां नमूने के कार्यान्वयन है IndexOf,

public static int IndexOf<T>(this IEnumerable<T> source, T item) 
    { 
     var entry = source.Select((x, i) => new { Value = x, Index = i }) 
        .Where(x => object.Equals(x.Value, item)) 
        .FirstOrDefault(); 
     return entry != null ? entry.Index : -1; 
    } 

CopyTo (IList<T>.IndexOf के रूप में ही है, लेकिन एक IEnumerable<T> पर काम करता है) (IList<T>.CopyTo के रूप में ही है, लेकिन एक IEnumerable<T> पर काम करता है)

public static void CopyTo<T>(this IEnumerable<T> source, T[] array, int startIndex) 
    { 
     int lowerBound = array.GetLowerBound(0); 
     int upperBound = array.GetUpperBound(0); 
     if (startIndex < lowerBound) 
      throw new ArgumentOutOfRangeException("startIndex", "The start index must be greater than or equal to the array lower bound"); 
     if (startIndex > upperBound) 
      throw new ArgumentOutOfRangeException("startIndex", "The start index must be less than or equal to the array upper bound"); 

     int i = 0; 
     foreach (var item in source) 
     { 
      if (startIndex + i > upperBound) 
       throw new ArgumentException("The array capacity is insufficient to copy all items from the source sequence"); 
      array[startIndex + i] = item; 
      i++; 
     } 
    } 

Answer 3

किसी .NET 2.0 या 3.5 में एक ConditionalWeakTable उपयोग करने के लिए की आवश्यकता होगी, के लिए वहाँ यह का बैकपोर्ट यहाँ है: https://github.com/theraot/Theraot/wiki/Features