List with non-null elements ends up containing null. A synchronization issue?
asynchronous, c#, list, null, synchronization
Solution
`List<T>` can only support multiple readers concurrently. If you are going to use multiple threads to add to the list, you'll need to lock the object first. There is really no way around this, because without a lock you can still have someone reading from the list while another thread updates it (or multiple objects trying to update it concurrently also).
http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx
Your best bet probably is to encapsulate the list in another object, and have that object handle the locking and unlocking actions on the internal list. That way you could make your new object's "Add" method asynchronous and let the calling objects go on their merry way. Any time you read from it though you'll most likely still have to wait on any other objects finishing their updates though.
Problem
First of all, sorry about the title -- I couldn't figure out one that was short and clear enough. Here's the issue: I have a list `List<MyClass> list` to which I always add newly-created instances of `MyClass`, like this: `list.Add(new MyClass())`. I don't add elements any other way. However, then I iterate over the list with `foreach` and find that there are some null entries. That is, the following code: ``` foreach (MyClass entry in list) if (entry == null) throw new Exception("null entry!"); ``` will sometimes throw an exception. I should point out that the `list.Add(new MyClass())` are performed from different threads running concurrently. The only thing I can think of to account for the `null` entries is the concurrent accesses. `List<>` isn't thread-safe, after all. Though I still find it strange that it ends up containing null entries, instead of just not offering any guarantees on ordering. Can you think of any other reason? Also, I don't care in which order the items are added, and I don't want the calling threads to block waiting to add their items. If synchronization is truly the issue, can you recommend a simple way to call the `Add` method asynchronously, i.e., create a delegate that takes care of that while my thread keeps running its code? I know I can create a delegate for `Add` and call `BeginInvoke` on it. Does that seem appropriate? Thanks. EDIT: A simple solution based on Kevin's suggestion: ``` public class AsynchronousList<T> : List<T> { private AddDelegate addDelegate; public delegate void AddDelegate(T item); public AsynchronousList() { addDelegate = new AddDelegate(this.AddBlocking); } public void AddAsynchronous(T item) { addDelegate.BeginInvoke(item, null, null); } private void AddBlocking(T item) { lock (this) { Add(item); } } } ``` I only need to control `Add` operations and I just need this for debugging (it won't be in the final product), so I just wanted a quick fix. Thanks everyone for your answers.