如何冻结集合以便可以迭代它？

Question

The following code gives me an exception:

var snapshot = BluetoothCapture.Instance.Snapshot();
var allowedDevice = snapshot.FirstOrDefault( _ => some_expression );

Collection was modified; enumeration operation may not execute.

I thought I could use a lock to freeze the collection so that I can iterate through it. However, I'm still getting the same exception.

The class definition below has a Snapshot method that attempts this:

public partial class BluetoothCapture
{
    ...

    public void Capture()
    {
        _watcher = DeviceInformation.CreateWatcher();
        _watcher.Added += (s, e) => { _devices.Add(e); };
        _watcher.Start();
    }

    public IEnumerable<DeviceInformation> Snapshot()
    {
        lock (_devices)
        {
            return _devices.AsReadOnly();
        }
    }
}

Any suggestions?

Answer 1

Lock is used when you need to stop a block of code to execute in multiple threads (stop the parallel execution). If Capture is called multiple times, so, yes, you can have a write being called before the previous one being finished.

You can use a ConcurrentBag. The ConcurrentBag is a list like object, but it is thread safe (none of generic list is). But, ConcurrentBag is unordered collection, so it does not guarantee ordering.

If you need some ordered list, you can see this link Thread safe collections in .NET

You can also make a "lock" in the Add (not in the get)

 _watcher.Added += (s, e) => { lock(_devices){_devices.Add(e); }};

But, if your app is running for a while, you can have a memory and performance problem (the add will be not async), even if the Capture is.

Answer 2

lock is really very useful concept but only when we use it wisely.

If in further code, your don't want to update reference of snapshot (the collection which you are getting from BluetoothCapture.Instance.Snapshot() ) but just perform some Linq query to get filtered value to perform some logic. you can avoid using lock .

It will be beneficial too, as by not doing lock you are actually not holding other threads to perform it's logic. - and we should not ignore the fact that terrible use of lock can cause serious problems like dead-lock too.

you are getting this exception, most likly, the collection on which you are performing linq query; is being updated by some other thread. (i too got that problem).

you can do one thing, instead of using general reference of collection (the one which you are getting from BluetoothCapture.Instance.Snapshot() ) you can create a local list - as it is local it will not be updated by other threads.