title: List<T>: Moving from immutable to changeable structure
body: <p>I am currently using quite heavily some List and I am looping very frequently via foreach over these lists. <br>
  Originally List was immuteable afer the startup. Now I have a requirement to amend the List during runtime from one thread only (a kind of listener). I need to remove from the List in object A and add to the list of object B. A and B are instances of the same class.<br>
  Unfortunaly there is no Synchronized List. What would you suggest me to do in this case? in my case speed is more important than synchronisation, thus I am currently working with copies of the lists for add/remove to avoid that the enumerators fail.<br>
  Do you have any other recommended way to deal with this?</p>
  
  <pre><code>class X {
      List&lt;T&gt; Related {get; set;}
  }
  </code></pre>
  
  <p>In several places and in different threads I am then using</p>
  
  <pre><code> foreach var x in X.Related
  </code></pre>
  
  <p>Now I need to basically perform in yet another thread</p>
  
  <pre><code>a.Related.Remove(t);
  b.Related.Add(t);
  </code></pre>
  
  <p>To avoid potential exceptions, I am currently doing this:</p>
  
  <pre><code>List&lt;T&gt; aNew=new List&lt;T&gt; (a.Related);
  aNew.Remove(t);
  a.Related=aNew;
  List&lt;T&gt;bNew=new List&lt;T&gt;(b.Related){t};
  b.Related=bNew;
  </code></pre>
  
  <p>Is this correct to avoid exceptions?</p>