title: C# thread safety with get/set
body: <p>This is a detail question for C#.</p>
  
  <p>Suppose I've got a class with an object, and that object is protected by a lock:</p>
  
  <pre><code>Object mLock = new Object();
  MyObject property;
  public MyObject MyProperty {
      get {
           return property;
      }
      set { 
           property = value; 
      }
  }
  </code></pre>
  
  <p>I want a polling thread to be able to query that property.  I also want the thread to update properties of that object occasionally, and sometimes the user can update that property, and the user wants to be able to see that property.  </p>
  
  <p>Will the following code properly lock the data?</p>
  
  <pre><code>Object mLock = new Object();
  MyObject property;
  public MyObject MyProperty {
      get {
           lock (mLock){
               return property;
           }
      }
      set { 
           lock (mLock){
                property = value; 
           }
      }
  }
  </code></pre>
  
  <p>By 'properly', what I mean is, if I want to call</p>
  
  <pre><code>MyProperty.Field1 = 2;
  </code></pre>
  
  <p>or whatever, will the field be locked while I do the update?  Is the setting that's done by the equals operator inside the scope of the 'get' function, or will the 'get' function (and hence the lock) finish first, and then the setting, and then 'set' gets called, thus bypassing the lock?</p>
  
  <p>Edit:  Since this apparently won't do the trick,  what will?  Do I need to do something like:</p>
  
  <pre><code>Object mLock = new Object();
  MyObject property;
  public MyObject MyProperty {
      get {
           MyObject tmp = null;
           lock (mLock){
               tmp = property.Clone();
           }
           return tmp;
      }
      set { 
           lock (mLock){
                property = value; 
           }
      }
  }
  </code></pre>
  
  <p>which more or less just makes sure that I only have access to a copy, meaning that if I were to have two threads call a 'get' at the same time, they would each start with the same value of Field1 (right?).  Is there a way to do read and write locking on a property that makes sense?  Or should I just constrain myself to locking on sections of functions rather than the data itself?</p>
  
  <p>Just so that this example makes sense:  MyObject is a device driver that returns status asynchronously.  I send it commands via a serial port, and then the device responds to those commands in its own sweet time.  Right now, I have a thread that polls it for its status ("Are you still there?  Can you accept commands?"), a thread that waits for responses on the serial port ("Just got status string 2, everything's all good"), and then the UI thread which takes in other commands ("User wants you to do this thing.") and posts the responses from the driver ("I've just done the thing, now update the UI with that").  That's why I want to lock on the object itself, rather than the fields of the object; that would be a huge number of locks, a, and b, not every device of this class has the same behavior, just general behavior, so I'd have to code lots of individual dialogs if I individualized the locks.</p>