Gute Implementierung des schwachen Wörterbuchs in .Net

Wo finde ich eine gute Umsetzung von IDictionary die verwendet schwache Referenzen drin?

Wörterbuch sollte mit ausschließlich schwachen verweisen auf Werte und schließlich bereinigen, die sich von Toten Referenzen.

Oder sollte ich einfach nur schreiben Sie es mir?

InformationsquelleAutor der Frage Konstantin Spirin | 2010-05-06

  1. 24

    ConditionalWeakTable Klasse verwendet schwache Schlüssel automatisch und entfernt das Schlüssel/Wert-Eintrag, sobald keine weiteren Referenzen auf ein Schlüssel existieren, der außerhalb der Tabelle.

    InformationsquelleAutor der Antwort madrang

  2. 5

    Müssen Sie es selbst schreiben. Es sollte relativ gerade nach vorne, die Umsetzung der IDictionary-Schnittstelle und Speicherung der ist-Werte als WeakReferences. Sie können dann überprüfen Sie die Werte auf hinzufügen/auswählen, um zu sehen, ob Sie noch am Leben sind.

    Pseudo-code - nicht wirklich kompilieren:

    public class WeakDictionary <TKey,TValue> : IDictionary<TKey,TValue>
{
    private IDictionary<TKey,WeakReference> _innerDictionary = new Dictionary<TKey,WeakReference>();


    public TValue Index[ TKey key ]
    {
        get{
            var reference = _innerDictionary[ key ];
            if( reference.IsAlive )
                return (TValue)reference.Target;
            throw new InvalidOperation( "Key not found." );
        }

    }

    private void Cull()
    {
        var deadKeys = new List<TKey>();
        foreach( var pair in _innerDictionary )
        {
            if( ! pair.Value.IsAlive )
                deadKeys.Add( pair.Key );
        }

        foreach( var key in deadKeys )
            _innerDictionary.Remove( key );
    }
}

    InformationsquelleAutor der Antwort Paul Alexander

  3. 0

    Es ist eine Sache zu haben WeakReferences zu Werten, aber ich fand, dass das Dictionary der Schlüssel kann auch eine Quelle von Speicherlecks. Hier ist ein bare bones Umsetzung mit WeakReference Tasten:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Common.library.collections {

    ///<summary>
    ///THIS DICTIONARY WILL NOT "HANG ON" TO THE KEYS IT USES
    ///IF THE KEY IS GARBAGE COLLECTED, THE VALUE WILL BE RELEASED TOO
    ///</summary>
    public class Dictionary_usingWeakKey<K, V> {
        //MAP FROM HASH CODE TO LIST OF KEY/VALUE PAIRS
        private Dictionary<int, List<Pair>> dic = new Dictionary<int, List<Pair>>();


        public void Add(K key, V value) {
            if (value==null){
                this.Remove(key);
                return;
            }//endif

            List<Pair> list = null;
            dic.TryGetValue(key.GetHashCode(), out list);
            if (list == null) {
                list = new List<Pair>();
                dic.Add(key.GetHashCode(), list);
            }//endif

            Boolean isDirty = false;            
            foreach(Pair p in list){
                if (p.Key.Target == null) {
                    isDirty = true;
                    continue;
                }//endif
                if (p.Key.Target == (Object)key) {
                    p.Value = (Object)value;
                    if (isDirty) cleanList(list);
                    return;
                }//endif
            }//for
            if (isDirty) cleanList(list);

            Pair newP=new Pair();
            newP.Key = new WeakReference(key);
            newP.Value = value;
            list.Add(newP);
        }//method


        public bool ContainsKey(K key) {
            List<Pair> list = null;
            dic.TryGetValue(key.GetHashCode(), out list);
            if (list == null) return false;

            Boolean isDirty = false;
            foreach (Pair p in list) {
                if (p.Key.Target == null) {
                    isDirty = true;
                    continue;
                }//endif
                if (p.Key.Target == (Object)key) {
                    if (isDirty) cleanList(list);
                    return true;
                }//endif
            }//for
            if (isDirty) cleanList(list);

            return false;
        }//method



        private void cleanList(List<Pair> list) {
            var temp = (from Pair p in list where p.Key.Target != null select p);
            list.Clear();
            list.AddRange(temp);
        }//method



        public bool Remove(K key) {
            List<Pair> list = null;
            dic.TryGetValue(key.GetHashCode(), out list);
            if (list == null) return true;

            foreach (Pair p in list) {
                if (p.Key.Target == (Object)key) {
                    p.Value = null;
                    break;
                }//endif
            }//for
            cleanList(list);

            return true;
        }//method





        public V this[K key] {
            get {
                List<Pair> list = null;
                dic.TryGetValue(key.GetHashCode(), out list);
                if (list == null) return default(V);

                Boolean isDirty = false;
                foreach (Pair p in list) {
                    if (p.Key.Target == null) {
                        isDirty = true;
                        continue;
                    }//endif

                    if (p.Key.Target == (Object)key) {
                        if (isDirty) cleanList(list);
                        return (V)p.Value;
                    }//endif
                }//for
                if (isDirty) cleanList(list);

                return default(V);
            }
            set {
                this.Add(key, value);
            }
        }


        public void Add(KeyValuePair<K, V> item) {
            throw new NotImplementedException();
        }

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

        public bool Contains(KeyValuePair<K, V> item) {
            throw new NotImplementedException();
        }

        public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex) {
            throw new NotImplementedException();
        }

        public int Count {
            get {
                throw new NotImplementedException();            
                //return dic.Count();           
            }
        }

        public bool IsReadOnly {
            get { return false; }
        }

        public bool Remove(KeyValuePair<K, V> item) {
            throw new NotImplementedException();
        }



        public IEnumerator<KeyValuePair<K, V>> GetEnumerator() {
            throw new NotImplementedException();    
            //return dic.GetEnumerator();
        }


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





    }//class



    public class Pair{
        public WeakReference Key;
        public Object Value;
    }//method

}

    InformationsquelleAutor der Antwort Kyle Lahnakoski

  4. 0

    Ein problem mit dem blossen halten von a dictionary of WeakReference-Objekte ist, dass es keine Möglichkeit gibt, kurz die Aufzählung der gesamte Wörterbuch, das entfernen aus dem Wörterbuch alle WeakReference-Objekte, deren Ziele außerhalb des Bereichs.

    Wäre es hilfreich, wenn eine WeakReference könnte einen Delegierten, der würde aufgerufen werden, wenn das primäre Ziel ging out of scope. Soweit ich weiß, gibt es keine Möglichkeit, das zu tun. Wenn Sie nichts dagegen haben, das hinzufügen eines weiteren Feldes und ein wenig code, um die Objekte, die Sie speichern in Ihrem "schwachen Wörterbuch", würde ich vorschlagen, das zu schaffen, was ich nenne eine "Finasposer" - Objekt, dessen einzige Feld ist ein MethodInvoker; wenn entsorgt, die MethodInvoker sollte genullt; der finalizer sollten Verzahnt.Exchange() die MethodInvoker auf null und-wenn die alte Wert war nicht null--es aufzurufen. Das Objekt geschrieben werden, in das Wörterbuch sollte erstellen Sie einen neuen Finasposer Objekt, mit einer Stellvertretung, die bewirken, dass der Schlüssel werden aus dem Wörterbuch entfernt werden, wenn bequem.

    Beachten Sie, dass das weder der finalizer noch alle Delegierten aufgerufen, dabei sollte nie direkt bearbeitet werden, das Wörterbuch, noch irgendetwas tun, das würde erfordern den Erwerb einer Sperre. Wenn die Finasposer hält delegieren, delegieren, selbst ist garantiert gültig, wenn Finalize ausgeführt wird, aber das Objekt angebracht, um den Delegierten und alle Objekte, die referenziert werden dadurch, kann in unerwartete Zustände. Es sollte sicher sein, aber für die Finasposer genannte Methode hinzufügen, um eine verknüpfte Liste eine Referenz auf das Objekt, das ging out-of-scope. Das Wörterbuch Hinzufügen, Entfernen und andere Methoden könnten eine Umfrage der verknüpften Liste, um zu sehen, wenn eine der WeakReferences darin gestorben und musste gereinigt werden.

    InformationsquelleAutor der Antwort supercat

  5. 0

    Wenn Identität-Vergleich kann nicht verwendet werden, dann ConditionalWeakTable ist keine option.

    In diesem Fall, ich wage zu unserer Umsetzung
    WeakTable.cs
    und unsere Beschreibung im blog
    WeakTable.

    InformationsquelleAutor der Antwort Vladimir Nesterovsky

Schreibe einen Kommentar