可以更新或删除的共享内存的线程安全枚举

我在线程之间有一个共享对象，用于保存文件状态信息。保存信息的对象是此类：

/// <summary>
/// A synchronized dictionary class.
/// Uses ReaderWriterLockSlim to handle locking. The dictionary does not allow recursion by enumeration. It is purly used for quick read access.
/// </summary>
/// <typeparam name="T">Type that is going to be kept.</typeparam>
public sealed class SynchronizedDictionary<U,T> : IEnumerable<T>
{
    private System.Threading.ReaderWriterLockSlim _lock = new System.Threading.ReaderWriterLockSlim();
    private Dictionary<U, T> _collection = null;
    public SynchronizedDictionary()
    {
        _collection = new Dictionary<U, T>();
    }
    /// <summary>
    /// if getting:
    /// Enters read lock.
    /// Tries to get the value.
    /// 
    /// if setting:
    /// Enters write lock.
    /// Tries to set value.
    /// </summary>
    /// <param name="key">The key to fetch the value with.</param>
    /// <returns>Object of T</returns>
    public T this[U key]
    { 
        get
        {
            _lock.EnterReadLock();
            try
            {
                return _collection[key];
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }
        set
        {
            Add(key, value);
        }
    }
    /// <summary>
    /// Enters write lock. 
    /// Removes key from collection
    /// </summary>
    /// <param name="key">Key to remove.</param>
    public void Remove(U key)
    {
        _lock.EnterWriteLock();
        try
        {
            _collection.Remove(key);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
    /// <summary>
    /// Enters write lock.
    /// Adds value to the collection if key does not exists.
    /// </summary>
    /// <param name="key">Key to add.</param>
    /// <param name="value">Value to add.</param>
    private void Add(U key, T value)
    {
        _lock.EnterWriteLock();
        if (!_collection.ContainsKey(key))
        {
            try
            {
                _collection[key] = value;
            }
            finally
            {
                _lock.ExitWriteLock();
            }
        }
    }
    /// <summary>
    /// Collection does not support iteration.
    /// </summary>
    /// <returns>Throw NotSupportedException</returns>
    public IEnumerator<T> GetEnumerator()
    {
        throw new NotSupportedException();
    }
    /// <summary>
    /// Collection does not support iteration.
    /// </summary>
    /// <returns>Throw NotSupportedException</returns>
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        throw new NotSupportedException();
    }

}

我这样称呼这本字典：SynchronizedDictionary _cache=新的SynchronizedDictionary（）；

其他线程可以派生并使用该线程，如下所示：_cache["key"]；

字典可以在运行时修改。我认为这里没有问题。还是我错了？在我看来，问题在于枚举器，因为我想制作一个遍历集合的枚举器。我该怎么做？我想到了这三种解决方案：

1. 制作这样的枚举器：http://www.codeproject.com/Articles/56575/Thread-safe-enumeration-in-C（但使用ReaderWriterLockSlim）
2. 像SyncRoot一样公开锁定对象（但使用ReaderWriterLockSlim），因此调用者调用enter和exit读取方法
3. 请使用数据库（SQLite fx）来保存信息

数字1）的问题是：

1. 它使用构造函数进入读取模式。如果GetEnumerator（）是手动调用的，而不是使用foreach？忘记调用dispose
2. 我不知道这是否是一个好的编码风格。尽管我喜欢代码
3. 如果调用者使用foreach，我不知道调用者可能会做什么在枚举器的实例化和对dispose的调用之间。如果我理解了我正确阅读的文档，这可以只要还有一个读者在做，最终就会阻止作者一些繁重的工作

数字2）的问题是：

1. 我不喜欢暴露这个。我知道.NET API能做到这一点，但是我不喜欢它
2. 正确进出取决于呼叫者

我的眼睛没有问题。但我把这个小项目作为业余项目来做，我想了解更多关于多线程和反射的知识，所以我想把它作为最后的选择。我之所以想在运行时迭代集合，是因为我想找到符合某些条件的值。

也许只有我发明了一个问题？

我知道ConcurrentDictionary，但我不想使用它。我把这个项目当作游乐场。玩线程和反射。

编辑

有人问我在读什么，在写什么。我将在这次编辑中讲述这一点。我正在读写这门课：

public class AssemblyInformation
{
    public string FilePath { get; private set; }
    public string Name { get; private set; }
    public AssemblyInformation(string filePath, string name)
    {
        FilePath = filePath;
        Name = name;
    }
}

我在运行时读了很多书，几乎没有写。也许我会写2000和1。也不会有太多的物体，可能有200个。