Get list of object's from collection being updated by thread

I have a Dictionary of items that a thread is updating. I want to have a method get the updated list of items using another thread.

Like so:

    internal List<string> GetListOfEntities()
    {            
        List<string> listOfEntities = new List<string>();
        foreach (string entityName in ModelFacade._totalListOfStkObjects.Keys)
        {
            listOfEntities.Add(entityName);
        }
        return listOfEntities;
    }

ModelFacade._totalListOfStkObjects is the collection being updated by the thread. I keep getting the exception: "Collection was modified; enumeration operation may not execute."; I have tried copying _totalListOfStkObjects to a local collection and iterating over that in GetListOfEntities().. but I get the same error..?

Any help ?

Wulf开发者_JS百科garPro

There isn't going to be a guaranteed thread-safe way to access the dictionary. Your best bet is to either change your code so that you're not sharing the collection or to to lock the dictionary when accessing:

object dictLock = new object();

internal List<string> GetListOfEntities()
{            
    lock (dictLock)
    {
        return ModelFacade._totalListOfStkObjects.Keys.ToList();
    }
}

Make sure you also lock the dictionary when modifying it in another thread.

Change your Dictionary to ConcurrentDictionary if you are using .NET 4. Here is an easy example to simulate your question and resolve it.

class DataItem
{
    public int Data { get; set; }
    public bool IsDirty { get; set; }
}

var data = new ConcurrentDictionary<string, DataItem>();
Thread addingItems = new Thread(() =>
    {
       for (int i = 0; i < 10000; i++)
       {
           data.TryAdd("data " + i, new DataItem { Data = i, IsDirty = true });
           Thread.Sleep(100);
       }
    });
Thread fetchingItems = new Thread(() =>
    {
        int count = 0;
        while (count < 100)
        {
            foreach (var item in data)
            {
                if (item.Value.IsDirty)
                {
                    Console.WriteLine(item.Key + " " + item.Value);
                    item.Value.IsDirty = false;
                    count++;
                }
            }
        }
    });
addingItems.Start();
fetchingItems.Start();

You can wrap the dictionary up in a thread-safe singleton class. This should provide all of the functionality of ConcurrentDictionary to Dictionary. Referencing the Dictionary should only require one additional layer of indirection.

Reference:

Singleton.Instance.myDictionary.Add(1, "Hello World");

Declaration:

public sealed class Singleton
{
    private static volatile Singleton instance;
    private static object syncRoot = new Object();
    public Dictionary<int, string> myDictionary = new Dictionary<int, string>();

    private Singleton() {}

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }
}

Look here for more information on the Singleton Pattern in C#. Note that there is only one difference between the pattern on this link and my example code.