CODEWITHSUNDEEP
c#multithreading
Rand Random
Rand Random

Reputation: 7440

Thread safe OfType

I am facing the problem that this code:

enumerable.OfType<Foo>().Any(x => x.Footastic == true);

Isnt thread safe and throws an enumeration has changed exception.

Is there a good way to overcome this issue?

Already tried the following but it didnt always work (seems to not fire this often)

public class Foo
{
    public void DoSomeMagicWithCollection(IEnumerable enumerable)
    {
        lock (enumerable)
        {
            enumerable.OfType<Foo>().Any(x => x.Footastic == true);
        }
    }
}

Upvotes: 2

Views: 214

Answers (1)

Servy
Servy

Reputation: 203842

If you're getting an exception that the underlying collection has changed while enumerating it, given that this code clearly doesn't mutate the collection itself, it means that another thread is mutating the collection while you're trying to iterate it.

There is no possible solution to this problem other than simply not doing that. What's happening is that the enumerator of the List (or whatever collection type that is) is throwing the exception and preventing further enumeration because it can see that the list was modified during the enumeration. There is no way for the enumerators of OfType of Any that wrap it to possibly recover from that. The underlying enumerator is refusing to give them the data from the list. They can't do anything about that.

You need to use some sort of synchronization mechanism to prevent another thread from mutating the collection wnile this thread is enumerating this collection. Your lock doesn't prevent another thread from using the collection, it simply prevents any code that locks on the same instance from running. You need to have any code that could possibly mutate the list also lock on the same object to properly synchronize them.

Another possibility would be to use a collection that is inherently designed to be accessed from multiple threads at the same time. There are several such collections in the System.Collections.Concurrent namespace. They may or may not fit your needs. They will take care of synchronizing access to their data (to a point) on their own, without you needing to explicitly lock when accessing them.

Upvotes: 7

Related Questions