The Weird and The Wonderful

ddecoy wrote:

I have no clue ...

supercat9 wrote:

The code isn't testing for alphanumeric--just alphabetic

David Skelly wrote:

It's also possible, of course, that whoever wrote it just didn't understand lock.

Daniel Grunwald wrote:

That's the only possible explanation.

supercat9 wrote:

if a lock must be held between calls to an objects methods or properties, it must be publicly available.

class ThreadedWhatsit
{
  public ThreadedWhatsit
  {
    lock(_Lock)
    {
      // do stuff
    }
  }
 
  public ThingType PropertyA
  {
    set
    {
      lock(_Lock)
      {
        _PropertyA = value;
      }
    }
    get
    {
      ThingType propertyA;
      lock(_Lock)
      {
        propertyA = _PropertyA;
      }
    }
  }
 
  private ThingType _PropertyA = new ThingType();
 
  private object _Lock = new object();
}

Gary R. Wheeler wrote:

An instance member marked private can be the lock value, manipulated solely by members of the class, like this

Agreed, but if one wishes to allow people to nicely enumerate collections I'm not sure there's always a good way around it. Personally, I wish that Microsoft's contract had allowed collections to be changed during an enumeration subject to some restrictions (basically, things which exist throughout an enumeration must be returned once; things that exist for part of an enumeration may be returned at most once) but that's not how Microsoft specified it.

I am well aware that locking a collection during enumeration is a dangerous recipe for deadlock, but there isn't always a practical alternative.