Concurrent collection enumerator

Question

I'm currently programming my own implementation of priority queue / sorted list and I would like to have it concurrent. In order to have it thread safe I'm using lock(someObject) and I would like to verify some behavior of mutexes in C#.

Inner representation of my sorted list is basically linked list with head and slots linked together. Something like:

internal class Slot
{
    internal T Value;
    internal Slot Next;

    public Slot(T value, Slot next = null)
    {
        Value = value;
        Next = next;
    }
}

Every time I'm manipulating with head I have to use lock(someObject)because of thread safety. In order to implement ICollection interface I have to implement public IEnumerator<T> GetEnumerator(). In this method I have take my head and read from it so I should use mutex.

public IEnumerator<T> GetEnumerator()
{
    lock (syncLock)
    {
        var curr = head;
        while (curr != null)
        {
            yield return curr.Value;
            curr = curr.Next;
        }
    }
}

My question is: Is syncLock locked for whole time in enumerator (so it will be unlocked after reaching end of the method) or it is automatically unlocked after yielding value?

Answer 1

Thank you guys from the comments, here's sum up.

Answer: yes, syncLock will be locked for the whole time → hence, it's a really bad idea

Possible solution:

• make collection not thread safe
• obtain lock, copy whole collection and return enumerator of this collection @Evk
• use some kind of boolean flag, set it on true while enumerating over the collection and throw exception when Add, Clear or Remove methods are called -> this is default List behavior @ManfredRadlwimmer
• make that collection immutable @InBetween