Finalisation de la collection Dictionary <object, IntPtr>

Question

J'ai une classe avec un champ de Dictionary<object, IntPtr>.

J'allouent la mémoire dynamique, lorsque l'utilisateur appelle une méthode de ma classe:

IntPtr somePointer = Marshal.AllocHGlobal(/*some desired size*/); 

Alors je vais utiliser cette mémoire dans un autre thread. En fait, après avoir effectué un travail, ce thread libère la mémoire allouée via Marshal.FreeHGlobal et supprime la clé appropriée de la collection. Mais il y a une certaine probabilité que ce thread se plante, donc je pense à une finalisation correcte.

Comment puis-je finaliser toute cette collection (dans le cas où un thread s'est écrasé et que ma mémoire reste allouée)? Je souhaite changer IntPtr en SafeHandle. Est-ce que cela aidera?

Answer 1

Ecrire une enveloppe pour le IntPtr pourrait certainement travailler. Mais il n'est pas nécessaire que la mémoire reste valide tant que l'élément est stocké dans le dictionnaire. Si c'est le cas, le code client est beaucoup plus simple si vous créez votre propre répertoire, qui libère automatiquement la mémoire lorsqu'un élément est supprimé du dictionnaire. Pas besoin pour le client d'appeler Dispose() pour chaque item, c'est toujours un avantage.

Pour cela, dérivez votre propre classe de IDictionary<object, IntPtr> et IDisposable. Vous pouvez simplement déléguer la plupart des appels de méthode à un dictionnaire privé. Vous aurez besoin d'un Add() personnalisé pour allouer la mémoire, Delete pour le libérer. Et implémentez Dispose() et le finaliseur pour nettoyer. Le code est un peu laid si:

class MyDictionary : IDictionary<object, IntPtr>, IDisposable { 
    private Dictionary<object, IntPtr> impl = new Dictionary<object, IntPtr>(); 

    public void Add(object key) { 
     IntPtr mem = Marshal.AllocCoTaskMem(666); // Something smarter here... 
     impl.Add(key, mem); 
    } 
    public bool Remove(object key) { 
     if (!impl.ContainsKey(key)) return false; 
     Marshal.FreeCoTaskMem(impl[key]); 
     return impl.Remove(key); 
    } 
    protected void Dispose(bool disposing) { 
     foreach (IntPtr mem in impl.Values) Marshal.FreeCoTaskMem(mem); 
     if (disposing) impl.Clear(); 
    } 
    public void Dispose() { 
     Dispose(true); 
    } 
    ~MyDictionary() { 
     Dispose(false); 
    } 

    // Boilerplate 
    public void Add(object key, IntPtr value) { throw new NotImplementedException(); } 
    public void Add(KeyValuePair<object, IntPtr> item) { throw new NotImplementedException(); } 
    public bool Remove(KeyValuePair<object, IntPtr> item) { throw new NotImplementedException(); } 
    public bool ContainsKey(object key) { return impl.ContainsKey(key); } 
    public ICollection<object> Keys { get { return impl.Keys; }} 
    public bool TryGetValue(object key, out IntPtr value) { return impl.TryGetValue(key, out value); } 
    public ICollection<IntPtr> Values { get {return impl.Values; }} 
    public IntPtr this[object key] { get { return impl[key]; } set { impl[key] = value; } } 
    public void Clear() { impl.Clear(); } 
    public bool Contains(KeyValuePair<object, IntPtr> item) { return impl.Contains(item); } 
    public void CopyTo(KeyValuePair<object, IntPtr>[] array, int arrayIndex) { (impl as ICollection<KeyValuePair<object, IntPtr>>).CopyTo(array, arrayIndex); } 
    public int Count { get { return impl.Count; }} 
    public bool IsReadOnly { get { return (impl as ICollection<KeyValuePair<object, IntPtr>>).IsReadOnly; } } 
    public IEnumerator<KeyValuePair<object, IntPtr>> GetEnumerator() { return impl.GetEnumerator(); } 
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return (impl as System.Collections.IEnumerable).GetEnumerator(); } 
} 

AllocCoTaskMem est le meilleur allocateur BTW, il n'a pas le bagage hérité.

Answer 2

Une option serait de mettre votre code thread dans un bloc try/finally et d'avoir enfin bloquer la mémoire, de cette façon si le thread plante (je suppose que vous voulez dire une exception?), Le bloc finally assurera la mémoire est libérée. Un SafeHandle personnalisé vous aidera si vous libérez la mémoire dans la méthode Dispose, mais pour que cela fonctionne, vous devrez avoir supprimé l'élément du dictionnaire avant que le thread ne se bloque, afin qu'il n'y ait plus de référence à la SafeHandle via le dictionnaire. Sinon, la mémoire n'est libérée qu'une fois le dictionnaire publié, ce qui dépend de la gestion de votre vie du dictionnaire.

Vous pouvez également envisager une solution plus exotique en utilisant un WeakReference, mais si vous le pouvez, je suggère le SafeHandle conjointement avec try/finally.

Answer 3

Je pense que vous trouverez SafeHandle juste appelle CloseHandle lors du nettoyage, ce que je ne pense pas est la même chose que FreeHGlobal.

Vous seriez probablement mieux d'ajouter le modèle complet Dispose/Finalizer à votre classe qui contient la collection, et de le parcourir à travers le dictionnaire et le nettoyage. Ou écrire un wrapper avec un finaliseur pour le HGlobal.

Mise à jour: Cela peut être utile - http://social.msdn.microsoft.com/forums/en-US/csharpgeneral/thread/f74b7c3c-12c4-466b-9754-82e9dea8b83e